private static void ExpectedResultSupplied( SyntaxNodeAnalysisContext context, IMethodSymbol methodSymbol, AttributeSyntax attributeNode, AttributeArgumentSyntax expectedResultNamedArgument) { var methodReturnValueType = methodSymbol.ReturnType; if (methodReturnValueType.IsAwaitable(out var awaitReturnType)) { if (awaitReturnType.SpecialType == SpecialType.System_Void) { context.ReportDiagnostic(Diagnostic.Create(asyncExpectedResultButReturnTypeNotGenericTask, attributeNode.GetLocation(), methodReturnValueType.ToDisplayString())); } else { ReportIfExpectedResultTypeCannotBeAssignedToReturnType( ref context, expectedResultNamedArgument, awaitReturnType); } } else { if (methodReturnValueType.SpecialType == SpecialType.System_Void) { context.ReportDiagnostic(Diagnostic.Create(specifiedExpectedResultForVoid, expectedResultNamedArgument.GetLocation())); } else { ReportIfExpectedResultTypeCannotBeAssignedToReturnType( ref context, expectedResultNamedArgument, methodReturnValueType); } } }
private static Location GetSecurityAttributeActionSyntaxLocation( AttributeSyntax?nodeOpt, TypedConstant typedValue, out object displayString ) { if (nodeOpt == null) { displayString = ""; return(NoLocation.Singleton); } var argList = nodeOpt.ArgumentList; if (argList == null || argList.Arguments.IsEmpty()) { // Optional SecurityAction parameter with default value. displayString = (FormattableString)$"{typedValue.ValueInternal}"; return(nodeOpt.Location); } AttributeArgumentSyntax argSyntax = argList.Arguments[0]; displayString = argSyntax.ToString(); return(argSyntax.Location); }
public void ParseAttributeArgument( int argumentIndex, AttributeArgumentSyntax argumentSyntax, SemanticModel semanticModel, ExpressionSyntax argumentExpression, IDictionary <AttributeParamName, object> result) { switch (argumentIndex) { case 0: AttributeArgumentParserHelper.ParseExpression( argumentExpression, result, AttributeParameterNames.Min ); break; case 1: AttributeArgumentParserHelper.ParseExpression( argumentExpression, result, AttributeParameterNames.Max ); break; } }
private string GetLiteral(AttributeArgumentSyntax argument, SemanticModel semanticModel) { var literal = argument.Expression.GetLiteral(semanticModel); // Literal would be wrapped in double quotes, removing them return(literal.Substring(1, literal.Length - 2)); }
private static async Task <Document> AddFriendClassAttributeAsync(Document document, ClassDeclarationSyntax?classDeclaration, string friendClassType, CancellationToken cancellationToken) { // 构造FriendClassAttribute 语法节点 AttributeArgumentSyntax attributeArgument = SyntaxFactory.AttributeArgument(SyntaxFactory.TypeOfExpression(SyntaxFactory.ParseTypeName(friendClassType))); AttributeSyntax attributeSyntax = SyntaxFactory.Attribute(SyntaxFactory.IdentifierName("FriendClassAttribute")) .WithArgumentList(SyntaxFactory.AttributeArgumentList(SyntaxFactory.SingletonSeparatedList(attributeArgument))); // 构造添加构造FriendClassAttribute 得AttributeList语法节点 SyntaxList <AttributeListSyntax>?attributes = classDeclaration?.AttributeLists.Add( SyntaxFactory.AttributeList(SyntaxFactory.SingletonSeparatedList(attributeSyntax)).NormalizeWhitespace()); if (attributes == null) { return(document); } // 构造替换AttributeList的 ClassDeclaration语法节点 ClassDeclarationSyntax?newClassDeclaration = classDeclaration?.WithAttributeLists(attributes.Value).WithAdditionalAnnotations(Formatter.Annotation); SyntaxNode?root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); if (root == null || classDeclaration == null || newClassDeclaration == null) { return(document); } // 构造替换classDeclaration的root语法节点 var newRoot = root.ReplaceNode(classDeclaration, newClassDeclaration); // 替换root语法节点 return(document.WithSyntaxRoot(newRoot)); }
private async Task <Document> MakeStringLengthSufficientForAutoNumberingAsync(Document document, TextSpan diagnosticSpan, int minLengthForAutoNumbering, CancellationToken cancellationToken) { SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); AttributeArgumentSyntax attributeArgument = GetAttributeArgumentNodeToBeReplaced(root, diagnosticSpan); if (attributeArgument == null || cancellationToken.IsCancellationRequested) { return(document); } AttributeArgumentSyntax modifiedArgument = attributeArgument.WithExpression( SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(minLengthForAutoNumbering))); if (modifiedArgument == null) { return(document); } var modifiedRoot = root.ReplaceNode(attributeArgument, modifiedArgument); return(document.WithSyntaxRoot(modifiedRoot)); }
private static Task <Document> ChangeLanguageNameAsync( Document document, AttributeArgumentSyntax attributeArgument, string languageName, CancellationToken cancellationToken) { if (_languageNames == null) { Interlocked.CompareExchange(ref _languageNames, LoadLanguageNames(), null); } AttributeArgumentSyntax newAttributeArgument = AttributeArgument( SimpleMemberAccessExpression( ParseName("global::Microsoft.CodeAnalysis.LanguageNames").WithSimplifierAnnotation(), IdentifierName(_languageNames[languageName]))); return(document.ReplaceNodeAsync(attributeArgument, newAttributeArgument, cancellationToken)); ImmutableDictionary <string, string> LoadLanguageNames() { return(typeof(LanguageNames) .GetRuntimeFields() .Where(f => f.IsPublic) .ToImmutableDictionary(f => (string)f.GetValue(null), f => f.Name)); } }
public static IParameterSymbol GetCorrespondingParameter(this AttributeArgumentSyntax argumentSyntax, SyntaxNodeAnalysisContext context) { var argumentPosition = argumentSyntax.GetArgumentPosition(); var calledMethodSymbol = argumentSyntax.GetCalledMethod(context); return(argumentPosition < calledMethodSymbol?.Parameters.Length ? calledMethodSymbol.Parameters[argumentPosition] : null); }
private static AttributeListSyntax CreateAttribute(string fieldName) { AttributeArgumentSyntax arg = SyntaxFactory.AttributeArgument(SyntaxFactory.ParseExpression("\"" + fieldName + "\"")); AttributeSyntax attr = SyntaxFactory.Attribute(SyntaxFactory.ParseName("XmlAttribute")).AddArgumentListArguments(arg); return(SyntaxFactory.AttributeList(SyntaxFactory.SeparatedList(new[] { attr }))); }
async Task <Document> RemoveArgumentAsync(Document document, AttributeArgumentSyntax argument, CancellationToken ct) { var editor = await DocumentEditor.CreateAsync(document, ct).ConfigureAwait(false); editor.RemoveNode(argument); return(editor.GetChangedDocument()); }
public static Location FindTypeExpressionOrNullLocation(this AttributeArgumentSyntax attributeArgumentSyntax) { var walker = new FindTypeLocationWalker(); walker.Visit(attributeArgumentSyntax); return(walker.TypeExpressionLocation); }
private static async Task <Document> RefactorAsync( Document document, AttributeSyntax attribute, CancellationToken cancellationToken) { TypeDeclarationSyntax typeDeclaration = attribute.FirstAncestor <TypeDeclarationSyntax>(); SemanticModel semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false); string propertyName = NameGenerator.Default.EnsureUniqueName(DefaultNames.DebuggerDisplayPropertyName, semanticModel, typeDeclaration.OpenBraceToken.Span.End); AttributeArgumentSyntax argument = attribute.ArgumentList.Arguments.First(); TypeDeclarationSyntax newTypeDeclaration = typeDeclaration.ReplaceNode( argument, argument.WithExpression( StringLiteralExpression($"{{{propertyName},nq}}")).WithTriviaFrom(argument.Expression)); string value = semanticModel .GetDeclaredSymbol(typeDeclaration, cancellationToken) .GetAttribute(MetadataNames.System_Diagnostics_DebuggerDisplayAttribute) .ConstructorArguments[0] .Value .ToString(); bool isVerbatim = SyntaxInfo.StringLiteralExpressionInfo(argument.Expression).IsVerbatim; ExpressionSyntax returnExpression = GetReturnExpression(value, isVerbatim); PropertyDeclarationSyntax propertyDeclaration = MarkTypeWithDebuggerDisplayAttributeRefactoring.DebuggerDisplayPropertyDeclaration(propertyName, returnExpression); newTypeDeclaration = MemberDeclarationInserter.Default.Insert(newTypeDeclaration, propertyDeclaration); return(await document.ReplaceNodeAsync(typeDeclaration, newTypeDeclaration, cancellationToken).ConfigureAwait(false)); }
private static AttributeArgumentSyntax AddParameterName( AttributeArgumentSyntax argument, SemanticModel semanticModel, CancellationToken cancellationToken = default(CancellationToken)) { if (argument.NameColon == null || argument.NameColon.IsMissing) { IParameterSymbol parameterSymbol = CSharpAnalysis.DetermineParameter( argument, semanticModel, allowParams: false, cancellationToken: cancellationToken); if (parameterSymbol != null) { return(argument .WithNameColon( NameColon(parameterSymbol.ToDisplayString(_symbolDisplayFormat)) .WithTrailingSpace()) .WithTriviaFrom(argument)); } } return(argument); }
public static string GetAttributeParamterLiteralValue( this AttributeArgumentSyntax @this) { var literalExpresion = @this.Expression as LiteralExpressionSyntax; return(literalExpresion != null ? literalExpresion.Token.ValueText : string.Empty); }
public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context) { var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false); if (root is null) { return; } var diagnostic = context.Diagnostics.First(); var diagnosticSpan = diagnostic.Location.SourceSpan; ExpressionSyntax?syntax = root.FindNode(diagnosticSpan) switch { AttributeArgumentSyntax attributeArgumentSyntax => attributeArgumentSyntax.Expression, ExpressionSyntax expressionSyntax => expressionSyntax, _ => null, }; if (syntax != null) { context.RegisterCodeFix( CodeAction.Create( title: Resources.OptionLongNameMustBePascalCaseFix, createChangedSolution: c => MakePascalCaseAsync(context.Document, syntax, c), equivalenceKey: Resources.OptionLongNameMustBePascalCaseFix), diagnostic); } }
public OneWayOperationMakeIsOneWayFalseCodeAction( IDocument document, AttributeArgumentSyntax attributeArgumentSyntax) { this.document = document; this.attributeArgumentSyntax = attributeArgumentSyntax; }
public static AttributeSyntax Attribute(NameSyntax name, AttributeArgumentSyntax argument) { return(SyntaxFactory.Attribute( name, AttributeArgumentList( SingletonSeparatedList(argument)))); }
private static MethodDeclarationSyntax CreateMethodFromExceptionType(AttributeArgumentSyntax attributeArgument, MethodDeclarationSyntax node) { var exceptionType = attributeArgument.GetExceptionType(); var rawStatement = CreateAssert(exceptionType, node); return(ReplaceMethodBody(rawStatement, node)); }
private string GetUnionTypeFromAttribute(AttributeArgumentSyntax args) { switch (args.Expression) { case LiteralExpressionSyntax attrLiteral: var literalValue = attrLiteral.Token.ValueText; if (literalValue != "null") { throw new Exception($"Union parameters must ne types or null at line {attrLiteral.GetLocation().GetLineSpan().StartLinePosition.Line}"); } return("null"); case TypeOfExpressionSyntax attrTypeOf: var typeSyntax = attrTypeOf.Type as IdentifierNameSyntax; if (typeSyntax != null) { return(typeSyntax.Identifier.ValueText); } else { var attrPredefined = attrTypeOf.Type as PredefinedTypeSyntax; if (attrPredefined == null) { throw new Exception($"Cant process identifier in AvroField attribute {args.Expression} at line {attrTypeOf.GetLocation().GetLineSpan().StartLinePosition.Line}"); } return(attrPredefined.Keyword.ValueText); } default: throw new Exception($"Unknown attribute expression type {args.Expression} at line {args.Expression.GetLocation().GetLineSpan().StartLinePosition.Line}"); } }
public IEnumerable <DiagnosticInfo> GetDiagnosticInfo(SyntaxNodeAnalysisContext context) { var result = new List <DiagnosticInfo>(); var method = context.Node as MethodDeclarationSyntax; foreach (AttributeListSyntax attributeList in method.AttributeLists) { foreach (AttributeSyntax attribute in attributeList.Attributes) { if (string.Compare(attribute.Name?.ToString(), "ValidateInput") != 0) { continue; } //Verify the namespace before proceeding var symbol = context.SemanticModel.GetSymbolInfo(attribute).Symbol as ISymbol; if (string.Compare(symbol?.ContainingNamespace.ToString(), "System.Web.Mvc", StringComparison.Ordinal) != 0) { continue; } AttributeArgumentListSyntax argumentList = attribute.ArgumentList; AttributeArgumentSyntax argument = argumentList.Arguments.First(); var value = context.SemanticModel.GetConstantValue(argument?.Expression); if (value.HasValue && (bool)value.Value == false) { result.Add(new DiagnosticInfo(attribute.GetLocation())); } } } return(result); }
public static object GetArgumentValue(this AttributeArgumentSyntax arg, SemanticModel semanticModel) { var argExpr = arg.ChildNodes().First(); return ((argExpr as MemberAccessExpressionSyntax)?.GetMemberValue(semanticModel) ?? throw new NotImplementedException()); }
private static MethodDeclarationSyntax CreateMethodFromExceptionMessage(AttributeArgumentSyntax expectedException, MethodDeclarationSyntax node) { var exceptionMessage = expectedException.Expression.ToString(); var rawStatement = CreateAssertFromExceptionMessage(node); var statementToAdd = CreateExtraAssert(exceptionMessage); return(ReplaceMethodBody(rawStatement, node).AddBodyStatements(statementToAdd)); }
public override Evaluation VisitAttributeArgument(AttributeArgumentSyntax node) { node.NameEquals?.Accept <Evaluation>(this); node.NameColon?.Accept <Evaluation>(this); node.Expression?.Accept <Evaluation>(this); return(base.VisitAttributeArgument(node)); }
public static Tuple <AttributeArgumentSyntax, object> EvaluateExpression(this AttributeArgumentSyntax syntax) { object value; return(syntax.Expression.TryEvaluateArgument(out value) ? new Tuple <AttributeArgumentSyntax, object>(syntax, value) : null); }
public static string ExtractArgumentFromAttribute(this AttributeArgumentSyntax arg) { return(arg.Expression switch { LiteralExpressionSyntax les when les.Kind() == SyntaxKind.StringLiteralExpression => les.Token.ValueText, _ => arg.ToString() });
public void ParseAttributeArgument( int argumentIndex, AttributeArgumentSyntax argumentSyntax, SemanticModel semanticModel, ExpressionSyntax argumentExpression, IDictionary <AttributeParamName, object> result) { }
public override void VisitAttributeArgument(AttributeArgumentSyntax node) { node.NameEquals?.Accept(this); node.NameColon?.Accept(this); node.Expression?.Accept(this); base.VisitAttributeArgument(node); }
private void HandleAttribute(SyntaxNodeAnalysisContext context) { AttributeSyntax syntax = (AttributeSyntax)context.Node; SymbolInfo symbolInfo = context.SemanticModel.GetSymbolInfo(syntax, context.CancellationToken); IMethodSymbol methodSymbol = symbolInfo.Symbol as IMethodSymbol; if (methodSymbol == null) { return; } if (!string.Equals("JsonObjectAttribute", methodSymbol.ContainingType?.Name, StringComparison.Ordinal)) { return; } if (syntax.ArgumentList?.Arguments.Count > 0) { bool?isOptIn = null; // check property assignments first, because they override the first argument when both are specified foreach (var attributeArgumentSyntax in syntax.ArgumentList.Arguments) { if (attributeArgumentSyntax.NameEquals == null) { continue; } if (!string.Equals("MemberSerialization", attributeArgumentSyntax.NameEquals.Name?.ToString(), StringComparison.Ordinal)) { continue; } if (IsMemberSerializationOptIn(context, attributeArgumentSyntax.Expression)) { return; } isOptIn = false; } if (!isOptIn.HasValue) { AttributeArgumentSyntax firstArgument = syntax.ArgumentList.Arguments[0]; if (firstArgument?.Expression != null && (firstArgument.NameColon == null || string.Equals("memberSerialization", firstArgument.NameColon?.Name?.ToString(), StringComparison.Ordinal)) && firstArgument.NameEquals == null) { if (IsMemberSerializationOptIn(context, firstArgument?.Expression)) { return; } } } } context.ReportDiagnostic(Diagnostic.Create(Descriptor, syntax.GetLocation())); }
public static string AttributeArgument(AttributeArgumentSyntax arg) { var output = SyntaxNode(arg.Expression); if (arg.NameColon != null) { output = SyntaxNode(arg.NameColon.Name) + ": " + output; } return output; }
public override SyntaxNode VisitAttributeArgument(AttributeArgumentSyntax node) { if (Array.IndexOf(_arguments, node) != -1) { return(AddParameterName(node, _semanticModel)); } return(base.VisitAttributeArgument(node)); }
public static IParameterSymbol DetermineParameter( this SemanticModel semanticModel, AttributeArgumentSyntax attributeArgument, bool allowParams = false, bool allowCandidate = false, CancellationToken cancellationToken = default(CancellationToken)) { return(DetermineParameterHelper.DetermineParameter(attributeArgument, semanticModel, allowParams, allowCandidate, cancellationToken)); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitAttributeArgument(AttributeArgumentSyntax node) { this.OnNodeVisited(node); if (!this.traverseRootOnly) base.VisitAttributeArgument(node); }
/// <summary> /// /// </summary> /// <param name="node"></param> public override sealed void VisitAttributeArgument(AttributeArgumentSyntax node) { this.OnNodeVisited(node, this.type.IsInstanceOfType(node)); base.VisitAttributeArgument(node); }
/// <summary> /// Initializes a new instance of the <see cref="AttributeArgument"/> class. /// </summary> /// <param name="syntaxNode"></param> /// <param name="kind"></param> /// <remarks> /// When providing the semantic model, some properites will be devised from that. /// </remarks> public AttributeArgument(AttributeArgumentSyntax syntaxNode, SemanticModel semanticModel) : base(syntaxNode, semanticModel) { }
/// <summary> /// Initializes a new instance of the <see cref="AttributeArgument"/> class. /// </summary> /// <param name="syntaxNode"></param> public AttributeArgument(AttributeArgumentSyntax syntaxNode) : this(syntaxNode, null) { }
public override void VisitAttributeArgument(AttributeArgumentSyntax node) { var saveCurrentScope = currentScope; currentScope = new DeclarationScope(saveCurrentScope); Visit(node.Expression); Debug.Assert(currentScope.Parent == saveCurrentScope); currentScope = saveCurrentScope; }
private Symbol BindNamedAttributeArgumentName(AttributeArgumentSyntax namedArgument, NamedTypeSymbol attributeType, DiagnosticBag diagnostics, out bool wasError, out LookupResultKind resultKind) { var identifierName = namedArgument.NameEquals.Name; var name = identifierName.Identifier.ValueText; LookupResult result = LookupResult.GetInstance(); HashSet<DiagnosticInfo> useSiteDiagnostics = null; this.LookupMembersWithFallback(result, attributeType, name, 0, ref useSiteDiagnostics); diagnostics.Add(identifierName, useSiteDiagnostics); Symbol resultSymbol = this.ResultSymbol(result, name, 0, identifierName, diagnostics, false, out wasError); resultKind = result.Kind; result.Free(); return resultSymbol; }
private IEnumerable<ITypeSymbol> InferTypeInAttributeArgument( int index, IEnumerable<ImmutableArray<IParameterSymbol>> parameterizedSymbols, AttributeArgumentSyntax argumentOpt = null) { if (argumentOpt != null && argumentOpt.NameEquals != null) { // [MyAttribute(Prop = ... return InferTypeInNameEquals(argumentOpt.NameEquals, argumentOpt.NameEquals.EqualsToken); } var name = argumentOpt != null && argumentOpt.NameColon != null ? argumentOpt.NameColon.Name.Identifier.ValueText : null; return InferTypeInArgument(index, parameterizedSymbols, name); }
private IEnumerable<ITypeSymbol> InferTypeInAttributeArgument(int index, IEnumerable<IMethodSymbol> methods, AttributeArgumentSyntax argumentOpt = null) { return InferTypeInAttributeArgument(index, methods.Select(m => m.Parameters), argumentOpt); }
private IEnumerable<ITypeSymbol> InferTypeInAttribute(AttributeSyntax attribute, int index, AttributeArgumentSyntax argumentOpt = null) { var info = this.semanticModel.GetSymbolInfo(attribute, cancellationToken); var methods = info.GetBestOrAllSymbols().OfType<IMethodSymbol>(); return InferTypeInAttributeArgument(index, methods, argumentOpt); }
private IEnumerable<ITypeSymbol> InferTypeInAttributeArgument(AttributeArgumentSyntax argument, SyntaxToken? previousToken = null, ArgumentSyntax argumentOpt = null) { if (previousToken.HasValue) { // If we have a position, then it must be after the colon or equals in an argument. if (argument.NameColon == null || argument.NameColon.ColonToken != previousToken || argument.NameEquals.EqualsToken != previousToken) { return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); } } if (argument.Parent != null) { var attribute = argument.Parent.Parent as AttributeSyntax; if (attribute != null) { var index = attribute.ArgumentList.Arguments.IndexOf(argument); return InferTypeInAttribute(attribute, index, argument); } } return SpecializedCollections.EmptyEnumerable<ITypeSymbol>(); }
public static IUnifiedArgumentSyntax Create(AttributeArgumentSyntax argument) { return new UnifiedArgumentSyntax(argument); }
public void VisitAttributeArgument(AttributeArgumentSyntax node) { if (node == null) throw new ArgumentNullException("node"); node.Validate(); if (node.NameColon != null) node.NameColon.Accept(this); if (node.NameEquals != null) node.NameEquals.Accept(this); node.Expression.Accept(this); }
private Document Delete(Document document, AttributeArgumentSyntax node) { var argumentList = node.FirstAncestorOrSelf<AttributeArgumentListSyntax>(); var newArgumentList = argumentList.RemoveNode(node, SyntaxRemoveOptions.KeepNoTrivia); return document.ReplaceNodeAsync(argumentList, newArgumentList, CancellationToken.None) .WaitAndGetResult_CodeModel(CancellationToken.None); }
private BoundExpression BindNamedAttributeArgument(AttributeArgumentSyntax namedArgument, NamedTypeSymbol attributeType, DiagnosticBag diagnostics) { bool wasError; LookupResultKind resultKind; Symbol namedArgumentNameSymbol = BindNamedAttributeArgumentName(namedArgument, attributeType, diagnostics, out wasError, out resultKind); ReportDiagnosticsIfObsolete(diagnostics, namedArgumentNameSymbol, namedArgument, hasBaseReceiver: false); Debug.Assert(resultKind == LookupResultKind.Viable || wasError); TypeSymbol namedArgumentType; if (wasError) { namedArgumentType = CreateErrorType(); // don't generate cascaded errors. } else { namedArgumentType = BindNamedAttributeArgumentType(namedArgument, namedArgumentNameSymbol, attributeType, diagnostics); } // BindRValue just binds the expression without doing any validation (if its a valid expression for attribute argument). // Validation is done later by AttributeExpressionVisitor BoundExpression namedArgumentValue = this.BindValue(namedArgument.Expression, diagnostics, BindValueKind.RValue); namedArgumentValue = GenerateConversionForAssignment(namedArgumentType, namedArgumentValue, diagnostics); // TODO: should we create an entry even if there are binding errors? var fieldSymbol = namedArgumentNameSymbol as FieldSymbol; IdentifierNameSyntax nameSyntax = namedArgument.NameEquals.Name; BoundExpression lvalue; if ((object)fieldSymbol != null) { var containingAssembly = fieldSymbol.ContainingAssembly as SourceAssemblySymbol; // We do not want to generate any unassigned field or unreferenced field diagnostics. containingAssembly?.NoteFieldAccess(fieldSymbol, read: true, write: true); lvalue = new BoundFieldAccess(nameSyntax, null, fieldSymbol, ConstantValue.NotAvailable, resultKind, fieldSymbol.Type); } else { var propertySymbol = namedArgumentNameSymbol as PropertySymbol; if ((object)propertySymbol != null) { lvalue = new BoundPropertyAccess(nameSyntax, null, propertySymbol, resultKind, namedArgumentType); } else { lvalue = BadExpression(nameSyntax, resultKind); } } return new BoundAssignmentOperator(namedArgument, lvalue, namedArgumentValue, namedArgumentType); }
private VirtualTreePoint GetEndPoint(SourceText text, AttributeArgumentSyntax node, EnvDTE.vsCMPart part) { int endPosition; switch (part) { case EnvDTE.vsCMPart.vsCMPartName: case EnvDTE.vsCMPart.vsCMPartAttributes: case EnvDTE.vsCMPart.vsCMPartHeader: case EnvDTE.vsCMPart.vsCMPartWhole: case EnvDTE.vsCMPart.vsCMPartBodyWithDelimiter: case EnvDTE.vsCMPart.vsCMPartHeaderWithAttributes: throw Exceptions.ThrowENotImpl(); case EnvDTE.vsCMPart.vsCMPartAttributesWithDelimiter: case EnvDTE.vsCMPart.vsCMPartBody: case EnvDTE.vsCMPart.vsCMPartNavigate: throw Exceptions.ThrowEFail(); case EnvDTE.vsCMPart.vsCMPartWholeWithAttributes: endPosition = node.Span.End; break; default: throw Exceptions.ThrowEInvalidArg(); } return new VirtualTreePoint(node.SyntaxTree, text, endPosition); }
private TypeSymbol BindNamedAttributeArgumentType(AttributeArgumentSyntax namedArgument, Symbol namedArgumentNameSymbol, NamedTypeSymbol attributeType, DiagnosticBag diagnostics) { if (namedArgumentNameSymbol.Kind == SymbolKind.ErrorType) { return (TypeSymbol)namedArgumentNameSymbol; } // SPEC: For each named-argument Arg in named-argument-list N: // SPEC: Let Name be the identifier of the named-argument Arg. // SPEC: Name must identify a non-static read-write public field or property on // SPEC: attribute class T. If T has no such field or property, then a compile-time error occurs. bool invalidNamedArgument = false; TypeSymbol namedArgumentType = null; invalidNamedArgument |= (namedArgumentNameSymbol.DeclaredAccessibility != Accessibility.Public); invalidNamedArgument |= namedArgumentNameSymbol.IsStatic; if (!invalidNamedArgument) { switch (namedArgumentNameSymbol.Kind) { case SymbolKind.Field: var fieldSymbol = (FieldSymbol)namedArgumentNameSymbol; namedArgumentType = fieldSymbol.Type; invalidNamedArgument |= fieldSymbol.IsReadOnly; invalidNamedArgument |= fieldSymbol.IsConst; break; case SymbolKind.Property: var propertySymbol = ((PropertySymbol)namedArgumentNameSymbol).GetLeastOverriddenProperty(this.ContainingType); namedArgumentType = propertySymbol.Type; invalidNamedArgument |= propertySymbol.IsReadOnly; var getMethod = propertySymbol.GetMethod; var setMethod = propertySymbol.SetMethod; invalidNamedArgument = invalidNamedArgument || (object)getMethod == null || (object)setMethod == null; if (!invalidNamedArgument) { invalidNamedArgument = getMethod.DeclaredAccessibility != Accessibility.Public || setMethod.DeclaredAccessibility != Accessibility.Public; } break; default: invalidNamedArgument = true; break; } } if (invalidNamedArgument) { return new ExtendedErrorTypeSymbol(attributeType, namedArgumentNameSymbol, LookupResultKind.NotAVariable, diagnostics.Add(ErrorCode.ERR_BadNamedAttributeArgument, namedArgument.NameEquals.Name.Location, namedArgumentNameSymbol.Name)); } if (!namedArgumentType.IsValidAttributeParameterType(Compilation)) { return new ExtendedErrorTypeSymbol(attributeType, namedArgumentNameSymbol, LookupResultKind.NotAVariable, diagnostics.Add(ErrorCode.ERR_BadNamedAttributeArgumentType, namedArgument.NameEquals.Name.Location, namedArgumentNameSymbol.Name)); } return namedArgumentType; }
private static Task<Document> UpdateValueOfArgumentAsync(Document document, SyntaxNode root, AttributeArgumentSyntax argument) { var newArgument = argument.WithExpression(GetNewAttributeValue()); return Task.FromResult(document.WithSyntaxRoot(root.ReplaceNode(argument, newArgument))); }
public static string GenerateNameForArgument( this SemanticModel semanticModel, AttributeArgumentSyntax argument) { // If it named argument then we use the name provided. if (argument.NameEquals != null) { return argument.NameEquals.Name.Identifier.ValueText; } return semanticModel.GenerateNameForExpression(argument.Expression); }
private string GetLiteral(AttributeArgumentSyntax argument, SemanticModel semanticModel) { var literal = argument.Expression.GetLiteral(semanticModel); // Literal would be wrapped in double quotes, removing them return literal.Substring(1, literal.Length - 2); }