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) { }