public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
// {deployment,resourceroup}().location are acceptable inside of the "location" parameter's
// default value, so don't traverse into the parameter's default value any further because we'll flag
// any other uses of those expressions.
return;
}
private IEnumerable <Diagnostic> ValidateIdentifierAccess(ParameterDeclarationSyntax syntax)
{
return(SyntaxAggregator.Aggregate(syntax, new List <Diagnostic>(), (accumulated, current) =>
{
if (current is VariableAccessSyntax)
{
var symbol = bindings[current];
// Error: already has error info attached, no need to add more
// Parameter: references are permitted in other parameters' default values as long as there is not a cycle (BCP080)
// Function: we already validate that a function cannot be used as a variable (BCP063)
// Output: we already validate that outputs cannot be referenced in expressions (BCP058)
if (symbol.Kind != SymbolKind.Error &&
symbol.Kind != SymbolKind.Parameter &&
symbol.Kind != SymbolKind.Function &&
symbol.Kind != SymbolKind.Output)
{
accumulated.Add(DiagnosticBuilder.ForPosition(current).CannotReferenceSymbolInParamDefaultValue());
}
}
return accumulated;
},
accumulated => accumulated));
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
currentDeclaration = declarations[syntax.Name.IdentifierName];
declarationAccessDict[currentDeclaration] = new List <SyntaxBase>();
base.VisitParameterDeclarationSyntax(syntax);
currentDeclaration = null;
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
base.VisitParameterDeclarationSyntax(syntax);
var symbol = new ParameterSymbol(this.context, syntax.Name.IdentifierName, syntax, syntax.Modifier);
this.declaredSymbols.Add(symbol);
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax) =>
this.BuildStatement(syntax, () =>
{
this.VisitNodes(syntax.LeadingNodes);
this.Visit(syntax.Keyword);
this.documentStack.Push(Nil);
this.Visit(syntax.Name);
this.Visit(syntax.Type);
this.Visit(syntax.Modifier);
});
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
allowedFlags = FunctionFlags.ParameterDecorator;
this.VisitNodes(syntax.LeadingNodes);
this.Visit(syntax.Keyword);
this.Visit(syntax.Name);
this.Visit(syntax.Type);
allowedFlags = FunctionFlags.ParamDefaultsOnly;
this.Visit(syntax.Modifier);
allowedFlags = FunctionFlags.Default;
}
public ParameterType?GetParameterType(ParameterDeclarationSyntax parameterDeclarationSyntax)
{
if (parameterDeclarationSyntax.ParameterType is SimpleTypeSyntax simpleTypeSyntax &&
simpleTypeSyntax is not null)
{
return(simpleTypeSyntax.TypeName switch
{
"array" => ParameterType.Array,
"bool" => ParameterType.Bool,
"int" => ParameterType.Int,
"object" => ParameterType.Object,
"string" => ParameterType.String,
_ => null,
});
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
=> AssignTypeWithDiagnostics(syntax, diagnostics => {
diagnostics.AddRange(this.ValidateIdentifierAccess(syntax));
// assume "any" type when the parameter has parse errors (either missing or was skipped)
var declaredType = syntax.ParameterType == null
? LanguageConstants.Any
: LanguageConstants.TryGetDeclarationType(syntax.ParameterType.TypeName);
if (declaredType == null)
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Type).InvalidParameterType()));
}
var assignedType = declaredType;
if (object.ReferenceEquals(assignedType, LanguageConstants.String))
{
var allowedItemTypes = SyntaxHelper.TryGetAllowedItems(syntax)?
.Select(item => typeManager.GetTypeInfo(item));
if (allowedItemTypes != null && allowedItemTypes.All(itemType => itemType is StringLiteralType))
{
assignedType = UnionType.Create(allowedItemTypes);
}
}
switch (syntax.Modifier)
{
case ParameterDefaultValueSyntax defaultValueSyntax:
diagnostics.AddRange(ValidateDefaultValue(defaultValueSyntax, assignedType));
break;
case ObjectSyntax modifierSyntax:
var modifierType = LanguageConstants.CreateParameterModifierType(declaredType, assignedType);
// we don't need to actually use the narrowed type; just need to use this to collect assignment diagnostics
TypeValidator.NarrowTypeAndCollectDiagnostics(typeManager, modifierSyntax, modifierType, diagnostics);
break;
}
return(assignedType);
});
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
diagnostics.AddRange(this.ValidateIdentifierAccess(syntax));
var assignedType = typeManager.GetTypeInfo(syntax);
switch (syntax.Modifier)
{
case ParameterDefaultValueSyntax defaultValueSyntax:
diagnostics.AddRange(ValidateDefaultValue(defaultValueSyntax, assignedType));
break;
case ObjectSyntax modifierSyntax:
if (assignedType.TypeKind != TypeKind.Error && SyntaxHelper.TryGetPrimitiveType(syntax) is PrimitiveType primitiveType)
{
var modifierType = LanguageConstants.CreateParameterModifierType(primitiveType, assignedType);
diagnostics.AddRange(TypeValidator.GetExpressionAssignmentDiagnostics(typeManager, modifierSyntax, modifierType));
}
break;
}
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
=> AssignTypeWithCaching(syntax, () => {
var primitiveType = LanguageConstants.TryGetDeclarationType(syntax.Type.TypeName);
if (primitiveType == null)
{
return(new ErrorTypeSymbol(DiagnosticBuilder.ForPosition(syntax.Type).InvalidParameterType()));
}
if (!object.ReferenceEquals(primitiveType, LanguageConstants.String))
{
return(primitiveType);
}
var allowedItemTypes = SyntaxHelper.TryGetAllowedItems(syntax)?
.Select(item => VisitAndReturnType(item));
if (allowedItemTypes == null || !allowedItemTypes.All(itemType => itemType is StringLiteralType))
{
return(primitiveType);
}
return(UnionType.Create(allowedItemTypes));
});
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax)
{
allowedFlags = FunctionFlags.ParamDefaultsOnly;
base.VisitParameterDeclarationSyntax(syntax);
allowedFlags = FunctionFlags.Default;
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax) => this.BuildStatement(syntax, () => base.VisitParameterDeclarationSyntax(syntax));
public ParameterSymbol(ISymbolContext context, string name, ParameterDeclarationSyntax declaringSyntax, SyntaxBase?modifier)
: base(context, name, declaringSyntax, declaringSyntax.Name)
{
this.Modifier = modifier;
}
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax) => this.BuildWithSpread(() => base.VisitParameterDeclarationSyntax(syntax));
public override void VisitParameterDeclarationSyntax(ParameterDeclarationSyntax syntax) => VisitDeclaration(syntax, base.VisitParameterDeclarationSyntax);
private DeclaredTypeAssignment GetParameterType(ParameterDeclarationSyntax syntax) => new DeclaredTypeAssignment(syntax.GetDeclaredType(), syntax);
public ParameterSymbol(ISymbolContext context, string name, ParameterDeclarationSyntax declaringSyntax)
: base(context, name, declaringSyntax, declaringSyntax.Name)
{
}
