Quick Fixes to create new parameters or variables when there are undefined symbols in bicep files.

[DrBushyTop]

Description

Adds a quick fix for BCP057 ("The name does not exist in the current context") that offers to create a parameter or variable declaration for undefined symbols. This makes using snippets without included parameters / variables much easier. This was requested in and fixes #12536

When determining the type for a new parameter, the fix first checks usage context (e.g., bool if used in a condition, int if used in arithmetic), then tries resource-derived input types for complex properties, then user-defined type aliases, and finally falls back to TypeStringifier for the inferred type.

Variables try to assign some reasonable defaults when created, inferred from types. However, for objects if there are more than 5 properties, the variable defaults to an empty object to not make too many assumptions which the user might need.

New declarations are inserted after the last existing declaration of the same kind, or at the start of the referencing statement.

Type inference requires semantic model APIs (GetDeclaredType, GetDeclaredTypeAssignment, contextual analysis) that aren't available during diagnostic emission, so this was implemented as an LSP code action rather than attached directly to the diagnostic.

Example Usage

Please check the included tests for further use cases. Here's a video showing some in the IDE.

UndefinedTypesQuickFix.webm

NOTE: Parameters passed through module context pass the resourceInput values through, but defined user types are not explicitly imported.

For example a module:

param enc resourceInput<'Microsoft.Storage/storageAccounts@2025-06-01'>.properties.encryption

param myCustomParam myParamType

type myParamType = {
  name: string
  kind: 'StorageV2' | 'BlobStorage' | 'FileStorage'
}

resource sa 'Microsoft.Storage/storageAccounts@2025-06-01' = {
  name: 'somename'
  location: 'westus'
  sku: {
    name: 'Premium_LRS'
  }
  kind: myCustomParam.kind
  properties: {
    encryption: enc
  }
}

Calling file's codefix produces

param encryption resourceInput<'Microsoft.Storage/storageAccounts@2025-06-01'>.properties.encryption
param myParam myParamType

module storage 'storage-account/base.bicep' = {
  name: 'myModule'
  params: {
    enc: encryption
    myCustomParam: myParam
  }
}

Checklist

• I have read and adhere to the contribution guide.

Microsoft Reviewers: Open in CodeFlow

[DrBushyTop]

@microsoft-github-policy-service agree

[anthony-c-martin]

Rather than retrospectively running this analysis on diagnostic codes, the approach we'd like to take is to use the Fixes array when raising the diagnostics in he first place. This doesn't require you to write a code fix provider.

See here for an example of what this looks like:

bicep/src/Bicep.Core/Diagnostics/DiagnosticBuilder.cs

Lines 1264 to 1268 in 63b642b

	public IDiagnostic MissingParameterAssignment(IEnumerable<string> identifiers, CodeFix insertMissingCodefix) => CoreError(
	"BCP258",
	$"The following parameters are declared in the Bicep file but are missing an assignment in the params file: {ToQuotedString(identifiers)}.")
	with
	{ Fixes = [insertMissingCodefix] };

[DrBushyTop]

Thanks for the review! I'm in the process of implementing the requested changes.

However, this one seems difficult in practice without sacrificing a lot of the functionality. If we want to keep the type inferring logic, formatting and placing the declarations in context etc. we do require SemanticModel, TypeManager, PrettyPrinterV2Context and so on. Those are not available when the diagnostic is raised in the first place, unless I'm totally mistaken.

Currently my refactored approach would move the implementation to Bicep.Core from the LangServer, and handle the creation in SemanticModel.AssembleDiagnostics() with

var disabledDiagnosticsCache = SourceFile.DisabledDiagnosticsCache;
foreach (IDiagnostic diagnostic in diagnostics)
{
    (int diagnosticLine, _) = TextCoordinateConverter.GetPosition(SourceFile.LineStarts, diagnostic.Span.Position);

    if (diagnosticLine == 0 || !diagnostic.CanBeSuppressed())
    {
        filteredDiagnostics.Add(AugmentDiagnostic(diagnostic)); // Here
        continue;
    }

    if (disabledDiagnosticsCache.TryGetDisabledNextLineDirective(diagnosticLine - 1) is { } disableNextLineDirectiveEndPositionAndCodes &&
        disableNextLineDirectiveEndPositionAndCodes.diagnosticCodes.Contains(diagnostic.Code))
    {
        continue;
    }

    filteredDiagnostics.Add(AugmentDiagnostic(diagnostic)); // And here
}
// ...snipped...

/// <summary>
/// Applies any diagnostic enrichments that require full semantic context
/// (for example, attaching code fixes) before diagnostics are surfaced
/// outside of the core compiler.
/// </summary>
private IDiagnostic AugmentDiagnostic(IDiagnostic diagnostic) => diagnostic.Code switch
{
    // BCP057 (undefined symbol) quick fixes depend on semantic information
    // such as type inference and declaration insertion points, which are
    // only available once the semantic model has been fully constructed.
    "BCP057" => AugmentWithUndefinedSymbolFixes(diagnostic),
    _ => diagnostic,
};

Thoughts?

[anthony-c-martin]

@jeskew - do you know if we have any existing code that could help with generating type syntax?

[jeskew]

There's a TypeStringifier utility that could be used for this.

[anthony-c-martin]

Rather than building syntax with strings, could you use the syntax factory here to generate the syntax tree? This makes it more straightforward to account for edge cases in code generation.

See here for an example:

bicep/src/Bicep.Core/Syntax/SyntaxFactory.cs

Lines 49 to 53 in 63b642b

	public static VariableBlockSyntax CreateVariableBlock(IEnumerable<IdentifierSyntax> variables)
	=> new(
	LeftParenToken,
	Interleave(variables.Select(x => new LocalVariableSyntax(x)), () => CommaToken),
	SyntaxFactory.RightParenToken);

[anthony-c-martin]

We have existing code to do this:

bicep/src/Bicep.Core/Extensions/IPositionableExtensions.cs

Line 19 in 63b642b

public static bool IsOverlapping(this IPositionable positionable, int position)

[anthony-c-martin]

Is it possible to use DeclaredTypeManager.GetDeclaredType() to obtain the expected type here, instead of having to write custom logic?

[anthony-c-martin]

It should be possible to reuse/share logic from

bicep/src/Bicep.LangServer/Handlers/InsertResourceHandler.cs

Line 191 in 63b642b

private static CodeReplacement GenerateCodeReplacement(BicepCompiler compiler, RootConfiguration configuration, ResourceDeclarationSyntax resourceDeclaration, InsertContext insertContext)

[anthony-c-martin]

Thanks for the contribution!

In general, I think there's quite a few existing concepts you should be able to re-use, rather than re-inventing. Definitely appreciate that it is not particularly easy to discover, so I'm very happy to share more detailed code pointers if my comments aren't clear enough, or you're not sure how to proceed.