implement "base" parameters support for extended bicepparam files (#17850)

polatengin · web-flow · commit d51c915482b4 · 2025-09-24T08:08:05.000-07:00
## Description Fixes #14522 and #17053 This PR implements the `base` keyword to enable seamless parameter merging and inheritance in Bicep parameter files. When extending parameter files, users can now reference parent parameter values using `base.<paramName>` to create complex merging scenarios without losing the ability to override specific values. ## Example Usage ```bicep // parent.bicepparam param tags = { environment: 'dev' team: 'platform' } param foo = 'foo' // child.bicepparam extends 'parent.bicepparam' param tags = { ...base.tags // Inherit parent tags environment: 'prod' // Override specific values region: 'westus2' // Add new values } param bar = base.foo ``` ## Checklist - [x] I have read and adhere to the [contribution guide](https://github.com/Azure/bicep/blob/main/CONTRIBUTING.md). ###### Microsoft Reviewers: [Open in CodeFlow](https://microsoft.github.io/open-pr/?codeflow=https://github.com/Azure/bicep/pull/17850)
diff --git a/src/Bicep.Cli.IntegrationTests/BuildParamsCommandTests.cs b/src/Bicep.Cli.IntegrationTests/BuildParamsCommandTests.cs
diff --git a/src/Bicep.Core/Diagnostics/DiagnosticBuilder.cs b/src/Bicep.Core/Diagnostics/DiagnosticBuilder.cs
@@ -1988,6 +1988,14 @@ public Diagnostic UsingWithClauseRequiresExperimentalFeature() => CoreError(
             public Diagnostic ExpectedWithKeywordOrNewLine() => CoreError(
                 "BCP436",
                 $"Expected the \"with\" keyword or a new line character at this location.");
+
+            public Diagnostic BaseIdentifierNotAvailableWithoutExtends() => CoreError(
+                "BCP437",
+                $"The identifier '{LanguageConstants.BaseIdentifier}' is only available in parameter files that declare an '{LanguageConstants.ExtendsKeyword}' clause.");
+
+            public Diagnostic BaseIdentifierRedeclared() => CoreError(
+                "BCP438",
+                $"The identifier '{LanguageConstants.BaseIdentifier}' is reserved and cannot be declared.");
         }
 
         public static DiagnosticBuilderInternal ForPosition(TextSpan span)
diff --git a/src/Bicep.Core/Intermediate/ExpressionBuilder.cs b/src/Bicep.Core/Intermediate/ExpressionBuilder.cs
@@ -1127,6 +1127,16 @@ private Expression ConvertVariableAccess(VariableAccessSyntax variableAccessSynt
             case ExtensionConfigAssignmentSymbol extensionConfigAssignmentSymbol:
                 return new ExtensionConfigAssignmentReferenceExpression(variableAccessSyntax, extensionConfigAssignmentSymbol);
 
+            case BaseParametersSymbol baseParamsSymbol:
+                var objectProperties = baseParamsSymbol.ParentAssignments
+                    .Select(pa => new ObjectPropertyExpression(
+                        pa.DeclaringParameterAssignment,
+                        new StringLiteralExpression(pa.DeclaringParameterAssignment.Name, pa.Name),
+                        ConvertWithoutLowering(pa.DeclaringParameterAssignment.Value)))
+                    .ToImmutableArray();
+
+                return new ObjectExpression(variableAccessSyntax, objectProperties);
+
             default:
                 throw new NotImplementedException($"Encountered an unexpected symbol kind '{symbol?.Kind}' and type '{symbol?.GetType().Name}' when generating a variable access expression.");
 
diff --git a/src/Bicep.Core/LanguageConstants.cs b/src/Bicep.Core/LanguageConstants.cs
@@ -96,6 +96,7 @@ public static class LanguageConstants
         public const string TargetScopeTypeLocal = "local";
 
         public const string CopyLoopIdentifier = "copy";
+        public const string BaseIdentifier = "base";
 
         public const string BicepConfigurationFileName = "bicepconfig.json";
 
diff --git a/src/Bicep.Core/Semantics/BaseParametersSymbol.cs b/src/Bicep.Core/Semantics/BaseParametersSymbol.cs
@@ -0,0 +1,50 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+using System.Collections.Immutable;
+using Bicep.Core.Diagnostics;
+using Bicep.Core.TypeSystem;
+using Bicep.Core.Syntax;
+using Bicep.Core.TypeSystem.Types;
+using Bicep.Core.Text;
+
+namespace Bicep.Core.Semantics
+{
+    public class BaseParametersSymbol : DeclaredSymbol
+    {
+        public BaseParametersSymbol(ISymbolContext context, ImmutableArray<ParameterAssignmentSymbol> parentAssignments) : base(context, LanguageConstants.BaseIdentifier, new ImplicitBaseIdentifierSyntax(parentAssignments.First().DeclaringParameterAssignment), parentAssignments.First().DeclaringParameterAssignment.Name)
+        {
+            this.ParentAssignments = parentAssignments;
+            this.syntheticSyntax = (ImplicitBaseIdentifierSyntax) this.DeclaringSyntax;
+        }
+
+        public ImmutableArray<ParameterAssignmentSymbol> ParentAssignments { get; }
+
+        private readonly ImplicitBaseIdentifierSyntax syntheticSyntax;
+
+    public override SymbolKind Kind => SymbolKind.BaseParameters;
+
+        public override IEnumerable<Symbol> Descendants => ParentAssignments;
+
+        public override void Accept(SymbolVisitor visitor)
+        {
+        }
+
+        public ImplicitBaseIdentifierSyntax SyntheticDeclaringSyntax => syntheticSyntax;
+    }
+
+    public sealed class ImplicitBaseIdentifierSyntax : SyntaxBase
+    {
+        private readonly ParameterAssignmentSyntax anchor;
+
+        public ImplicitBaseIdentifierSyntax(ParameterAssignmentSyntax anchor)
+        {
+            this.anchor = anchor;
+        }
+
+    public override TextSpan Span => anchor.Span;
+
+        public override void Accept(ISyntaxVisitor visitor)
+        {
+        }
+    }
+}
diff --git a/src/Bicep.Core/Semantics/Binder.cs b/src/Bicep.Core/Semantics/Binder.cs
@@ -40,29 +40,75 @@ public Binder(
             this.NamespaceResolver = NamespaceResolver.Create(namespaceResults);
 
             var fileScope = DeclarationVisitor.GetDeclarations(namespaceResults, sourceFile, symbolContext);
-            this.Bindings = NameBindingVisitor.GetBindings(sourceFile.ProgramSyntax, NamespaceResolver, fileScope);
-            this.cyclesBySymbol = CyclicCheckVisitor.FindCycles(sourceFile.ProgramSyntax, this.Bindings);
 
-            var extendsDeclarations = sourceFile.ProgramSyntax.Declarations.OfType<ExtendsDeclarationSyntax>();
+            // Process extends & synthesize 'base' BEFORE name binding so variable accesses to 'base' bind correctly.
+            var extendsDeclarations = sourceFile.ProgramSyntax.Declarations.OfType<ExtendsDeclarationSyntax>().ToImmutableArray();
+            bool hasExtends = extendsDeclarations.Any();
+            var parentParameterAssignments = ImmutableArray<ParameterAssignmentSymbol>.Empty;
 
-            foreach (var extendsDeclaration in extendsDeclarations)
+            if (hasExtends)
             {
-                if (sourceFileLookup.TryGetSourceFile(extendsDeclaration).TryUnwrap() is { } extendedFile &&
-                    modelLookup.GetSemanticModel(extendedFile) is SemanticModel extendedModel)
+                foreach (var extendsDeclaration in extendsDeclarations)
                 {
-                    var parameterAssignments = ImmutableArray<ParameterAssignmentSymbol>.Empty;
-                    foreach (var assignment in extendedModel.Root.ParameterAssignments)
+                    if (!(sourceFileLookup.TryGetSourceFile(extendsDeclaration).TryUnwrap() is { } extendedFile &&
+                        modelLookup.GetSemanticModel(extendedFile) is SemanticModel extendedModel))
                     {
-                        if (!fileScope.Locals.Any(e => e.Name == assignment.Name))
+                        continue;
+                    }
+
+                    var allParentAssignments = extendedModel.Root.ParameterAssignments;
+                    foreach (var assignment in allParentAssignments)
+                    {
+                        if (!parentParameterAssignments.Any(a => string.Equals(a.Name, assignment.Name, LanguageConstants.IdentifierComparison)))
                         {
-                            parameterAssignments = parameterAssignments.Add(assignment);
+                            parentParameterAssignments = parentParameterAssignments.Add(assignment);
                         }
                     }
 
-                    fileScope = fileScope.ReplaceLocals(fileScope.Locals.AddRange(parameterAssignments));
+                    var parentVariables = extendedModel.Root.VariableDeclarations.OfType<VariableSymbol>().ToImmutableArray();
+
+                    var nonConflicting = allParentAssignments.Where(a => !fileScope.Locals.Any(e => string.Equals(e.Name, a.Name, LanguageConstants.IdentifierComparison)));
+                    fileScope = fileScope.ReplaceLocals(fileScope.Locals.AddRange(nonConflicting));
+
+                    var nonConflictingVars = parentVariables.Where(v => !fileScope.Locals.Any(e => string.Equals(e.Name, v.Name, LanguageConstants.IdentifierComparison)));
+                    fileScope = fileScope.ReplaceLocals(fileScope.Locals.AddRange(nonConflictingVars));
+                }
+
+                if (parentParameterAssignments.Any())
+                {
+                    var localsWithoutOldBase = fileScope.Locals.Where(l => l is not BaseParametersSymbol).ToImmutableArray();
+                    fileScope = fileScope.ReplaceLocals(localsWithoutOldBase.Add(new BaseParametersSymbol(symbolContext, parentParameterAssignments)));
+                }
+            }
+
+            var baseBindings = NameBindingVisitor.GetBindings(sourceFile.ProgramSyntax, NamespaceResolver, fileScope).ToBuilder();
+
+            if (hasExtends && parentParameterAssignments.Any())
+            {
+                foreach (var parentAssignment in parentParameterAssignments)
+                {
+                    ProcessSyntaxForBinding(
+                        parentAssignment.DeclaringParameterAssignment.Value,
+                        parentAssignment.Context.Binder,
+                        baseBindings);
+                }
+
+                var inheritedVariables = fileScope.Locals.OfType<VariableSymbol>()
+                    .Where(v => !ReferenceEquals(v.Context.SourceFile, sourceFile))
+                    .ToImmutableArray();
+
+                foreach (var inheritedVar in inheritedVariables)
+                {
+                    ProcessSyntaxForBinding(
+                        inheritedVar.DeclaringVariable.Value,
+                        inheritedVar.Context.Binder,
+                        baseBindings);
                 }
             }
 
+            this.Bindings = baseBindings.ToImmutable();
+            this.cyclesBySymbol = CyclicCheckVisitor.FindCycles(sourceFile.ProgramSyntax, this.Bindings);
+
             this.FileSymbol = new FileSymbol(
                 symbolContext,
                 sourceFile,
@@ -119,5 +165,48 @@ private ImmutableHashSet<DeclaredSymbol> CalculateReferencedSymbolClosure(Declar
 
             return builder.ToImmutable();
         }
+
+        private void ProcessSyntaxForBinding(
+            SyntaxBase rootSyntax,
+            IBinder parentBinder,
+            IDictionary<SyntaxBase, Symbol> baseBindings)
+        {
+            var stack = new Stack<SyntaxBase>();
+            stack.Push(rootSyntax);
+
+            while (stack.Count > 0)
+            {
+                var current = stack.Pop();
+
+                if (current is VariableAccessSyntax || current == rootSyntax || current is PropertyAccessSyntax || current is ArrayAccessSyntax)
+                {
+                    var parentSymbol = parentBinder.GetSymbolInfo(current);
+                    if (parentSymbol is not null && !baseBindings.ContainsKey(current))
+                    {
+                        baseBindings[current] = parentSymbol;
+                    }
+                }
+
+                var childNodes = current switch
+                {
+                    ObjectSyntax obj => obj.Properties.Select(p => p.Value),
+                    ArraySyntax arr => arr.Items.Select(i => i.Value),
+                    PropertyAccessSyntax propAccess => [propAccess.BaseExpression],
+                    ArrayAccessSyntax arrayAccess => [arrayAccess.BaseExpression, arrayAccess.IndexExpression],
+                    FunctionCallSyntaxBase funcCall => funcCall.Arguments.Select(a => a.Expression),
+                    ParenthesizedExpressionSyntax paren => [paren.Expression],
+                    TernaryOperationSyntax ternary => [ternary.ConditionExpression, ternary.TrueExpression, ternary.FalseExpression],
+                    BinaryOperationSyntax binary => [binary.LeftExpression, binary.RightExpression],
+                    UnaryOperationSyntax unary => [unary.Expression],
+                    NonNullAssertionSyntax nonNull => [nonNull.BaseExpression],
+                    _ => []
+                };
+
+                foreach (var child in childNodes)
+                {
+                    stack.Push(child);
+                }
+            }
+        }
     }
 }
diff --git a/src/Bicep.Core/Semantics/SemanticDiagnosticVisitor.cs b/src/Bicep.Core/Semantics/SemanticDiagnosticVisitor.cs
@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 using System.Collections.Immutable;
 using Bicep.Core.Diagnostics;
+using Bicep.Core.SourceGraph;
 using Bicep.Core.Syntax;
 using Bicep.Core.TypeSystem;
 
@@ -97,6 +98,55 @@ public override void VisitFileSymbol(FileSymbol symbol)
                     }
                 }
             }
+
+            if (symbol.FileKind == BicepSourceFileKind.ParamsFile)
+            {
+                var hasExtends = extendsSyntaxes.Length == 1;
+
+                if (!hasExtends)
+                {
+                    foreach (var access in FindVariableAccesses(symbol.Syntax, LanguageConstants.BaseIdentifier))
+                    {
+                        this.diagnosticWriter.Write(access.Name, x => x.BaseIdentifierNotAvailableWithoutExtends());
+                    }
+                }
+                else
+                {
+                    foreach (var decl in symbol.Declarations.Where(d => string.Equals(d.Name, LanguageConstants.BaseIdentifier, LanguageConstants.IdentifierComparison) && d is not BaseParametersSymbol))
+                    {
+                        this.diagnosticWriter.Write(decl.DeclaringSyntax, x => x.BaseIdentifierRedeclared());
+                    }
+                }
+            }
+        }
+
+        private static IEnumerable<VariableAccessSyntax> FindVariableAccesses(SyntaxBase root, string identifier)
+        {
+            var results = new List<VariableAccessSyntax>();
+            var visitor = new VariableAccessCollector(identifier, results);
+            root.Accept(visitor);
+            return results;
+        }
+
+        private sealed class VariableAccessCollector : CstVisitor
+        {
+            private readonly string identifier;
+            private readonly IList<VariableAccessSyntax> results;
+
+            public VariableAccessCollector(string identifier, IList<VariableAccessSyntax> results)
+            {
+                this.identifier = identifier;
+                this.results = results;
+            }
+
+            public override void VisitVariableAccessSyntax(VariableAccessSyntax syntax)
+            {
+                if (syntax.Name.IdentifierName == identifier)
+                {
+                    results.Add(syntax);
+                }
+                base.VisitVariableAccessSyntax(syntax);
+            }
         }
 
         public override void VisitVariableSymbol(VariableSymbol symbol)
diff --git a/src/Bicep.Core/Semantics/SymbolKind.cs b/src/Bicep.Core/Semantics/SymbolKind.cs
@@ -23,6 +23,7 @@ public enum SymbolKind
         ParameterAssignment,
         Metadata,
         TypeAlias,
-        ExtensionConfigAssignment
+        ExtensionConfigAssignment,
+        BaseParameters
     }
 }
diff --git a/src/Bicep.Core/TypeSystem/TypeAssignmentVisitor.cs b/src/Bicep.Core/TypeSystem/TypeAssignmentVisitor.cs
@@ -2430,6 +2430,9 @@ public override void VisitVariableAccessSyntax(VariableAccessSyntax syntax)
                     case WildcardImportSymbol wildcardImport:
                         return wildcardImport.Type;
 
+                    case BaseParametersSymbol baseParameters:
+                        return new DeferredTypeReference(() => VisitDeclaredSymbol(syntax, baseParameters));
+
                     default:
                         return ErrorType.Create(DiagnosticBuilder.ForPosition(syntax.Name.Span).SymbolicNameIsNotAVariableOrParameter(syntax.Name.IdentifierName));
                 }
diff --git a/src/Bicep.Core/TypeSystem/TypeManager.cs b/src/Bicep.Core/TypeSystem/TypeManager.cs
@@ -1,9 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+using System.Collections.Concurrent;
+
 using Bicep.Core.Diagnostics;
 using Bicep.Core.Intermediate;
 using Bicep.Core.Semantics;
 using Bicep.Core.Syntax;
+using Bicep.Core.TypeSystem.Types;
 
 namespace Bicep.Core.TypeSystem
 {
@@ -12,6 +15,7 @@ public class TypeManager : ITypeManager
         // stores results of type checks
         private readonly TypeAssignmentVisitor typeAssignmentVisitor;
         private readonly DeclaredTypeManager declaredTypeManager;
+        private readonly IBinder binder;
 
         public TypeManager(SemanticModel model, IBinder binder)
         {
@@ -20,10 +24,47 @@ public TypeManager(SemanticModel model, IBinder binder)
             // (using the IReadOnlyDictionary to prevent accidental mutation)
             this.typeAssignmentVisitor = new(this, model);
             this.declaredTypeManager = new(this, binder, model.Features);
+            this.binder = binder;
         }
 
         public TypeSymbol GetTypeInfo(SyntaxBase syntax)
-            => typeAssignmentVisitor.GetTypeInfo(syntax);
+        {
+            if (syntax is ImplicitBaseIdentifierSyntax synthetic)
+            {
+                return GetSyntheticBaseParametersType(synthetic);
+            }
+
+            return typeAssignmentVisitor.GetTypeInfo(syntax);
+        }
+
+        private readonly ConcurrentDictionary<ImplicitBaseIdentifierSyntax, TypeSymbol> syntheticBaseTypes = new();
+
+        private TypeSymbol GetSyntheticBaseParametersType(ImplicitBaseIdentifierSyntax syntax)
+        {
+            return syntheticBaseTypes.GetOrAdd(syntax, key =>
+            {
+                if (this.declaredTypeManager is null)
+                {
+                    return LanguageConstants.Any;
+                }
+
+                if (this.binder.FileSymbol.Declarations.OfType<BaseParametersSymbol>().FirstOrDefault(s => ReferenceEquals(s.DeclaringSyntax, key)) is not { } baseSymbol)
+                {
+                    return LanguageConstants.Any;
+                }
+
+                var namedProperties = baseSymbol.ParentAssignments
+                    .GroupBy(pa => pa.Name, LanguageConstants.IdentifierComparer)
+                    .Select(group => group.First())
+                    .Select(pa => new NamedTypeProperty(pa.Name, GetTypeInfo(pa.DeclaringParameterAssignment.Value), TypePropertyFlags.ReadOnly));
+
+                return new ObjectType(
+                    name: "baseParameters",
+                    validationFlags: TypeSymbolValidationFlags.Default,
+                    properties: namedProperties,
+                    additionalProperties: null);
+            });
+        }
 
         public TypeSymbol? GetDeclaredType(SyntaxBase syntax)
             => declaredTypeManager.GetDeclaredType(syntax);

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@ public enum SymbolKind`
`23`	`23`	`ParameterAssignment,`
`24`	`24`	`Metadata,`
`25`	`25`	`TypeAlias,`
`26`		`- ExtensionConfigAssignment`
	`26`	`+ ExtensionConfigAssignment,`
	`27`	`+ BaseParameters`
`27`	`28`	`}`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2430,6 +2430,9 @@ public override void VisitVariableAccessSyntax(VariableAccessSyntax syntax)`
`2430`	`2430`	`case WildcardImportSymbol wildcardImport:`
`2431`	`2431`	`return wildcardImport.Type;`
`2432`	`2432`
	`2433`	`+ case BaseParametersSymbol baseParameters:`
	`2434`	`+ return new DeferredTypeReference(() => VisitDeclaredSymbol(syntax, baseParameters));`
	`2435`	`+`
`2433`	`2436`	`default:`
`2434`	`2437`	`return ErrorType.Create(DiagnosticBuilder.ForPosition(syntax.Name.Span).SymbolicNameIsNotAVariableOrParameter(syntax.Name.IdentifierName));`
`2435`	`2438`	`}`