feat: add support for loadTextContent function in extendable parameter files (#18424)

Fixes #18370 

## Description

The fix ensures that when evaluating parameters from extended files, the
evaluator uses the correct `ExpressionConverter` that corresponds to the
semantic model of the file where the parameter was originally declared.
This allows functions like `loadTextContent()` to resolve file paths
correctly relative to their defining file.

## Example Usage

```bicep
// example.txt
This is an example txt file.

// main.bicep
param foo object

// base.bicepparam
using none
param foo = {
  bar: loadTextContent('./example.txt')
}

// main.bicepparam
using './main.bicep'
extends './base.bicepparam'
```

To build the `main.bicepparam`, use the following command;

```shell
dotnet run --project ./src/Bicep.Cli/Bicep.Cli.csproj -- build-params ./main.bicepparam
```

With the fixes in this PR building the bicepparam will succeed.

_PS : `Build_params_with_extends_and_loadTextContent_in_base_succeeds`
test is to ensure the fix works 👍_

## 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/18424)

Author: polatengin

src/Bicep.Cli.IntegrationTests/BuildParamsCommandTests.cs

@@ -1283,5 +1283,71 @@ param organizationProfile resourceInput<'Microsoft.DevOpsInfrastructure/pools@20
             var kindValue = parametersObject["parameters"]?["organizationProfile"]?["value"]?["kind"]?.ToString();
             kindValue.Should().Be("AzureDevOps");
         }
+
+        [TestMethod]
+        public async Task Build_params_with_extends_and_loadTextContent_in_base_succeeds()
+        {
+            var outputPath = FileHelper.GetUniqueTestOutputPath(TestContext);
+
+            var exampleTxtFile = FileHelper.SaveResultFile(
+                TestContext,
+                "example.txt",
+                "This is an example txt file.",
+                outputPath);
+
+            var baseParamsFile = FileHelper.SaveResultFile(
+                TestContext,
+                "base.bicepparam",
+                """
+                using none
+
+                param foo = {
+                 bar: loadTextContent('./example.txt')
+                }
+                """,
+                outputPath);
+
+            var mainParamsFile = FileHelper.SaveResultFile(
+                TestContext,
+                "main.bicepparam",
+                """
+                using './main.bicep'
+                extends './base.bicepparam'
+                """,
+                outputPath);
+
+            FileHelper.SaveResultFile(
+                TestContext,
+                "main.bicep",
+                """
+                #disable-next-line no-unused-params
+                param foo object
+                """,
+                outputPath);
+
+            FileHelper.SaveResultFile(
+                TestContext,
+                "bicepconfig.json",
+                """
+                {
+                    "experimentalFeaturesEnabled": {
+                        "extendableParamFiles": true
+                    }
+                }
+                """,
+                outputPath);
+
+            var settings = CreateDefaultSettings();
+            var result = await Bicep(settings, "build-params", mainParamsFile, "--stdout");
+
+            result.Should().Succeed();
+
+            var parametersStdout = result.Stdout.FromJson<BuildParamsStdout>();
+            parametersStdout.Should().NotBeNull();
+
+            var parametersObject = JObject.Parse(parametersStdout!.parametersJson);
+            var bar = parametersObject["parameters"]?["foo"]?["value"]?["bar"]?.ToString();
+            bar.Should().Be("This is an example txt file.");
+        }
     }
 }

src/Bicep.Core/Emit/ParameterAssignmentEvaluator.cs

@@ -15,6 +15,7 @@
 using Bicep.Core.Intermediate;
 using Bicep.Core.Semantics;
 using Bicep.Core.Semantics.Metadata;
+using Bicep.Core.SourceGraph;
 using Bicep.Core.Syntax;
 using Microsoft.WindowsAzure.ResourceStack.Common.Extensions;
 using Newtonsoft.Json;
@@ -149,7 +150,9 @@ private Result(JToken? value, Expression? expression, ParameterKeyVaultReference
     private readonly ConcurrentDictionary<Expression, Result> synthesizedVariableResults = new();
     private readonly ConcurrentDictionary<SemanticModel, ResultWithDiagnosticBuilder<Template>> templateResults = new();
     private readonly ConcurrentDictionary<Template, TemplateVariablesEvaluator> armEvaluators = new();
+    private readonly ConcurrentDictionary<SemanticModel, ExpressionConverter> converterCache = new();
     private readonly ImmutableDictionary<string, ParameterAssignmentSymbol> paramsByName;
+    private readonly SemanticModel semanticModel;
     private readonly ImmutableDictionary<string, VariableSymbol> variablesByName;
     private readonly ImmutableDictionary<string, DeclaredFunctionSymbol> functionsByName;
     private readonly ImmutableDictionary<string, ImportedSymbol> importsByName;
@@ -158,8 +161,70 @@ private Result(JToken? value, Expression? expression, ParameterKeyVaultReference
     private readonly ExternalInputReferences externalInputReferences;
     private readonly ExpressionConverter converter;
 
+    private static IEnumerable<FunctionVariable> CollectFunctionVariablesIncludingExtends(SemanticModel model, EmitterContext context)
+    {
+        foreach (var functionVariable in context.FunctionVariables.Values)
+        {
+            yield return functionVariable;
+        }
+
+        if (model.SourceFile is not BicepParamFile)
+        {
+            yield break;
+        }
+
+        var visitedModels = new HashSet<ISemanticModel>();
+
+        foreach (var extendsDeclaration in model.SourceFile.ProgramSyntax.Declarations.OfType<ExtendsDeclarationSyntax>())
+        {
+            foreach (var functionVariable in CollectFunctionVariablesFromExtendedModel(model, extendsDeclaration, visitedModels))
+            {
+                yield return functionVariable;
+            }
+        }
+    }
+
+    private static IEnumerable<FunctionVariable> CollectFunctionVariablesFromExtendedModel(SemanticModel currentModel, ExtendsDeclarationSyntax extendsDeclaration, HashSet<ISemanticModel> visitedModels)
+    {
+        if (!currentModel.TryGetReferencedModel(extendsDeclaration).IsSuccess(out var extendedModel))
+        {
+            yield break;
+        }
+
+        if (!visitedModels.Add(extendedModel))
+        {
+            yield break;
+        }
+
+        if (extendedModel is not SemanticModel extendedSemanticModel)
+        {
+            yield break;
+        }
+
+        var extendedContext = new EmitterContext(extendedSemanticModel);
+
+        foreach (var functionVariable in extendedContext.FunctionVariables.Values)
+        {
+            yield return functionVariable;
+        }
+
+        if (extendedSemanticModel.SourceFile is BicepParamFile)
+        {
+            var nestedExtendsDeclarations = extendedSemanticModel.SourceFile.ProgramSyntax.Declarations.OfType<ExtendsDeclarationSyntax>();
+
+            foreach (var nestedExtendsDeclaration in nestedExtendsDeclarations)
+            {
+                foreach (var functionVariable in CollectFunctionVariablesFromExtendedModel(extendedSemanticModel, nestedExtendsDeclaration, visitedModels))
+                {
+                    yield return functionVariable;
+                }
+            }
+        }
+    }
+
     public ParameterAssignmentEvaluator(SemanticModel model)
     {
+        this.semanticModel = model;
         this.paramsByName = model.Root.ParameterAssignments
             .GroupBy(x => x.Name, LanguageConstants.IdentifierComparer)
             .ToImmutableDictionary(x => x.Key, x => x.First(), LanguageConstants.IdentifierComparer);
@@ -172,20 +237,36 @@ public ParameterAssignmentEvaluator(SemanticModel model)
 
         EmitterContext context = new(model);
         this.converter = new(context);
+        this.converterCache[model] = this.converter;
         this.importsByName = context.SemanticModel.ImportClosureInfo.ImportedSymbolNames.Keys
             .Select(importedVariable => (context.SemanticModel.ImportClosureInfo.ImportedSymbolNames[importedVariable], importedVariable))
             .GroupBy(x => x.Item1, LanguageConstants.IdentifierComparer)
             .ToImmutableDictionary(x => x.Key, x => x.First().importedVariable, LanguageConstants.IdentifierComparer);
         this.wildcardImportPropertiesByName = context.SemanticModel.ImportClosureInfo.WildcardImportPropertyNames
             .GroupBy(x => x.Value, LanguageConstants.IdentifierComparer)
             .ToImmutableDictionary(x => x.Key, x => x.First().Key, LanguageConstants.IdentifierComparer);
-        this.synthesizedVariableValuesByName = context.FunctionVariables.Values
+        this.synthesizedVariableValuesByName = CollectFunctionVariablesIncludingExtends(model, context)
             .GroupBy(result => result.Name)
             .ToImmutableDictionary(x => x.Key, x => x.First().Value);
 
         this.externalInputReferences = context.ExternalInputReferences;
     }
 
+    private ExpressionConverter GetConverterForParameter(ParameterAssignmentSymbol parameter)
+    {
+        if (ReferenceEquals(parameter.Context.SourceFile, semanticModel.SourceFile))
+        {
+            return converter;
+        }
+
+        if (parameter.Context.ModelLookup.GetSemanticModel(parameter.Context.SourceFile) is SemanticModel parameterModel)
+        {
+            return converterCache.GetOrAdd(parameterModel, model => new ExpressionConverter(new EmitterContext(model)));
+        }
+
+        return converter;
+    }
+
     public Result EvaluateParameter(ParameterAssignmentSymbol parameter)
         => results.GetOrAdd(
             parameter,
@@ -195,7 +276,8 @@ public Result EvaluateParameter(ParameterAssignmentSymbol parameter)
 
                 var declaringParam = parameter.DeclaringParameterAssignment;
 
-                var intermediate = converter.ConvertToIntermediateExpression(declaringParam.Value);
+                var parameterConverter = GetConverterForParameter(parameter);
+                var intermediate = parameterConverter.ConvertToIntermediateExpression(declaringParam.Value);
 
                 if (this.externalInputReferences.ParametersReferences.Contains(parameter))
                 {
@@ -212,7 +294,7 @@ public Result EvaluateParameter(ParameterAssignmentSymbol parameter)
 
                 try
                 {
-                    return Result.For(converter.ConvertExpression(intermediate).EvaluateExpression(context));
+                    return Result.For(parameterConverter.ConvertExpression(intermediate).EvaluateExpression(context));
                 }
                 catch (Exception ex)
                 {

src/Bicep.Core/Intermediate/ExpressionBuilder.cs

@@ -884,8 +884,7 @@ [.. method.Arguments.Select(a => ConvertWithoutLowering(a.Expression))]),
 
     private Expression ConvertFunction(FunctionCallSyntaxBase functionCall)
     {
-        if (Context.Settings.FileKind == BicepSourceFileKind.BicepFile &&
-            Context.FunctionVariables.GetValueOrDefault(functionCall) is { } functionVariable)
+        if (Context.FunctionVariables.GetValueOrDefault(functionCall) is { } functionVariable)
         {
             return new SynthesizedVariableReferenceExpression(functionCall, functionVariable.Name);
         }