Removed FunctionPlacementFlags

src/Bicep.Core/Emit/FunctionPlacementValidatorVisitor.cs

@@ -76,7 +76,7 @@ public override void VisitFunctionCallSyntax(FunctionCallSyntax syntax)
 
         private void VerifyModuleSecureParameterFunctionPlacement(FunctionCallSyntaxBase syntax)
         {
-            if (semanticModel.GetSymbolInfo(syntax) is FunctionSymbol functionSymbol && functionSymbol.PlacementFlags.HasFlag(FunctionPlacementFlags.ModuleSecureParameterOnly))
+            if (semanticModel.GetSymbolInfo(syntax) is FunctionSymbol functionSymbol && functionSymbol.FunctionFlags.HasFlag(FunctionFlags.ModuleSecureParameterOnly))
             {
                 // we can check placement only for funtions that were matched and has a proper placement flag
                 var (_, levelUpSymbol) = syntaxRecorder.Skip(1).FirstOrDefault();

src/Bicep.Core/Semantics/FunctionOverload.cs

@@ -14,15 +14,14 @@ public class FunctionOverload
     {
         public delegate TypeSymbol ReturnTypeBuilderDelegate(IEnumerable<FunctionArgumentSyntax> arguments);
 
-        public FunctionOverload(string name, string description, ReturnTypeBuilderDelegate returnTypeBuilder, TypeSymbol returnType, IEnumerable<FixedFunctionParameter> fixedParameters, VariableFunctionParameter? variableParameter, FunctionFlags flags = FunctionFlags.Default, FunctionPlacementFlags placementFlags = FunctionPlacementFlags.Default)
+        public FunctionOverload(string name, string description, ReturnTypeBuilderDelegate returnTypeBuilder, TypeSymbol returnType, IEnumerable<FixedFunctionParameter> fixedParameters, VariableFunctionParameter? variableParameter, FunctionFlags flags = FunctionFlags.Default)
         {
             this.Name = name;
             this.Description = description;
             this.ReturnTypeBuilder = returnTypeBuilder;
             this.FixedParameters = fixedParameters.ToImmutableArray();
             this.VariableParameter = variableParameter;
             this.Flags = flags;
-            this.PlacementFlags = placementFlags;
 
             this.MinimumArgumentCount = this.FixedParameters.Count(fp => fp.Required) + (this.VariableParameter?.MinimumCount ?? 0);
             this.MaximumArgumentCount = this.VariableParameter == null ? this.FixedParameters.Length : (int?)null;
@@ -46,8 +45,6 @@ public FunctionOverload(string name, string description, ReturnTypeBuilderDelega
 
         public FunctionFlags Flags { get; }
 
-        public FunctionPlacementFlags PlacementFlags { get; }
-
         public string TypeSignature { get; }
 
         public IEnumerable<string> ParameterTypeSignatures => this.FixedParameters

src/Bicep.Core/Semantics/FunctionOverloadBuilder.cs

@@ -36,8 +36,6 @@ public FunctionOverloadBuilder(string name)
 
         protected FunctionFlags Flags { get; private set; }
 
-        public FunctionPlacementFlags PlacementFlags { get; private set; }
-
         public FunctionOverload Build()
         {
             this.Validate();
@@ -52,8 +50,7 @@ public virtual FunctionOverload BuildInternal() =>
                 this.ReturnType,
                 this.FixedParameters.ToImmutable(),
                 this.VariableParameter,
-                this.Flags,
-                this.PlacementFlags);
+                this.Flags);
 
         public FunctionOverloadBuilder WithDescription(string description)
         {
@@ -103,13 +100,6 @@ public FunctionOverloadBuilder WithFlags(FunctionFlags flags)
             return this;
         }
 
-        public FunctionOverloadBuilder WithPlacementFlags(FunctionPlacementFlags flags)
-        {
-            this.PlacementFlags = flags;
-
-            return this;
-        }
-
         protected virtual void Validate()
         {
             // required params can only be at the beginning

src/Bicep.Core/Semantics/FunctionSymbol.cs

@@ -21,14 +21,6 @@ public FunctionSymbol(string name, IEnumerable<FunctionOverload> overloads)
                 // we should catch this as early as possible
                 throw new ArgumentException("Inconsistent function flags found on overloads");
             }
-
-            PlacementFlags = Overloads.First().PlacementFlags;
-
-            if (Overloads.Skip(1).Any(fo => fo.PlacementFlags != PlacementFlags))
-            {
-                // we should catch this as early as possible
-                throw new ArgumentException("Inconsistent placement flags found on overloads");
-            }
         }
 
         public override void Accept(SymbolVisitor visitor) => visitor.VisitFunctionSymbol(this);
@@ -38,7 +30,5 @@ public FunctionSymbol(string name, IEnumerable<FunctionOverload> overloads)
         public ImmutableArray<FunctionOverload> Overloads { get; }
 
         public FunctionFlags FunctionFlags { get; }
-        public FunctionPlacementFlags PlacementFlags { get; }
-
     }
 }

src/Bicep.Core/TypeSystem/Az/AzResourceTypeProvider.cs

@@ -247,7 +247,7 @@ private static IEnumerable<FunctionOverload> GetBicepMethods(ResourceTypeReferen
                         .WithDescription("Gets a reference to a key vault secret, which can be provided to a secure string module parameter")
                         .WithRequiredParameter("secretName", LanguageConstants.String, "Secret Name")
                         .WithOptionalParameter("secretVersion", LanguageConstants.String, "Secret Version")
-                        .WithPlacementFlags(FunctionPlacementFlags.ModuleSecureParameterOnly)
+                        .WithFlags(FunctionFlags.ModuleSecureParameterOnly)
                         .Build();
                     break;
             }

src/Bicep.Core/TypeSystem/FunctionFlags.cs

@@ -50,6 +50,11 @@ public enum FunctionFlags
         /// </summary>
         OutputDecorator = 1 << 6,
 
+        /// <summary>
+        /// The function can be used in direct assignment to a module parameter with @secure decorator
+        /// </summary>
+        ModuleSecureParameterOnly = 1 << 7,
+
         /// <summary>
         /// The function can be used a resource or module decorator.
         /// </summary>