public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { if (AttributeMatchUtil.HasTriviaAnnotationSimple(node.GetLeadingTrivia(), WidenAttributeName)) { node = (IdentifierNameSyntax)WidenType(node); } node = (IdentifierNameSyntax)base.VisitIdentifierName(node); return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbol = semanticModel.GetSymbolInfo(node).Symbol; node = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (symbol != null && symbol.IsStatic && symbol.ContainingType != null && (symbol is IMethodSymbol || symbol is IPropertySymbol || symbol is IFieldSymbol || symbol is IEventSymbol) && !(node.Parent is MemberAccessExpressionSyntax)) { if (symbol is IMethodSymbol && ((IMethodSymbol)symbol).IsGenericMethod) { var genericName = SyntaxHelper.GenerateGenericName(node.Identifier, ((IMethodSymbol)symbol).TypeArguments); return(genericName.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia())); } return(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(node.GetLeadingTrivia(), symbol.FullyQualifiedName(), node.GetTrailingTrivia()))); } return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { ISymbol referencedSymbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; if (referencedSymbol != null && referencedSymbol.Equals(this.fieldSymbol)) { return(Syntax.IdentifierName(this.getterName) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia())); } return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { // We only care about xml doc comments var leadingTrivia = CanHaveDocComments(node) ? VisitList(node.GetLeadingTrivia()) : node.GetLeadingTrivia(); if (_namespaceMembers.Contains(node.Identifier.Text)) { var expanded = Simplifier.Expand <SyntaxNode>(node, _model, _workspace, cancellationToken: _cancellationToken); return(expanded.WithLeadingTrivia(leadingTrivia)); } return(node.WithLeadingTrivia(leadingTrivia)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { CheckCastContex(node); CheckParenthesizeContex(node); var newNode = SyntaxFactoryExtensions.DataCodeVirtualAccess(); string name = node.Identifier.Text; string typeText = ""; bool found = false; VirtualData virtualData = null; foreach (var data in _virtualizationContext.data) { if (data.Name.Equals(name)) { typeText = data.Type; found = true; virtualData = data; break; } } if (!found) { return(node); } newNode = newNode.WithAdditionalAnnotations(virtualData.Annotations); var newExpression = newNode; if (CastEnabled) { newExpression = SyntaxFactory.CastExpression(SyntaxFactory.IdentifierName ( @"" + typeText ), newNode ); } if (ParenthesizeEnabled) { newExpression = SyntaxFactory.ParenthesizedExpression(newExpression); } newExpression = newExpression.WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()) ; return(newExpression); }
private async Task <Solution> UseTypeExplicit(Document document, IdentifierNameSyntax identifierName, TypeInfo typeInfo, CancellationToken cancellationToken) { var root = await document.GetSyntaxRootAsync(); var newIdentifierName = SyntaxFactory.ParseTypeName(typeInfo.ConvertedType.ToString()) .WithAdditionalAnnotations(Simplifier.Annotation) .WithLeadingTrivia(identifierName.GetLeadingTrivia()) .WithTrailingTrivia(identifierName.GetTrailingTrivia()); var newDocument = document.WithSyntaxRoot(root.ReplaceNode(identifierName, newIdentifierName)); return(newDocument.Project.Solution); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { ISymbol referencedSymbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; // Static members don't have to be qualified if (referencedSymbol == null || referencedSymbol.IsStatic) { return(base.VisitIdentifierName(node)); } // Check is the name already qualified. If so, no further action is needed (only top-most identifier may be qualified) // Considers: // a.>b<.foo() -> a.b.foo() if (node.Ancestors().OfType <MemberAccessExpressionSyntax>().Any(n => n.Name.DescendantNodesAndSelf().Contains(node))) { return(base.VisitIdentifierName(node)); } // Considers: // >a<.b.foo() -> newParameter.a.b.foo() if (referencedSymbol.Kind == CommonSymbolKind.Field || referencedSymbol.Kind == CommonSymbolKind.Method || referencedSymbol.Kind == CommonSymbolKind.Property || referencedSymbol.Kind == CommonSymbolKind.Event) { // Special case: constructor of different type is an unqualified and non-static member if (referencedSymbol.Kind == CommonSymbolKind.Method) { MethodSymbol method = (MethodSymbol)referencedSymbol; if (method.MethodKind == MethodKind.Constructor) { return(base.VisitIdentifierName(node)); } } // Create new context with leading trivia of old context IdentifierNameSyntax parameterIdentifier = Syntax.IdentifierName(this.newParameterNameToken) .WithLeadingTrivia(node.GetLeadingTrivia()); // And remove leading trivia from old context IdentifierNameSyntax context = node.WithLeadingTrivia(); return(Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, parameterIdentifier, context)); } return(base.VisitIdentifierName(node)); }
private async Task <Document> MakeUppercaseAsync(Document document, IdentifierNameSyntax identifierName, string propertyName, CancellationToken cancellationToken) { var newLiteral = SyntaxFactory.ParseExpression($"this.{propertyName}") .WithLeadingTrivia(identifierName.GetLeadingTrivia()) .WithTrailingTrivia(identifierName.GetTrailingTrivia()); SyntaxNode root = await document.GetSyntaxRootAsync(cancellationToken); var newRoot = root.ReplaceNode(identifierName, newLiteral); var newDocument = document.WithSyntaxRoot(newRoot); // use this to debug the result //var semanticModel2 = await newDocument.GetSemanticModelAsync(cancellationToken); return(newDocument); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { node = (IdentifierNameSyntax)base.VisitIdentifierName(node); ExpressionSyntax newNameString; if (Rename(AttributeMatchUtil.TriviaAnnotationToAttributesList(node.GetLeadingTrivia()), out newNameString)) { string newName = ((LiteralExpressionSyntax)newNameString).Token.Text; if (newName.StartsWith("\"") && newName.EndsWith("\"")) { newName = newName.Substring(1, newName.Length - 2); } node = node.WithIdentifier(SyntaxFactory.Identifier(newName)); } return(node); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax name) { // TODO: Hanlde initializer list correctly var symbolInfo = _semanticModel.GetSymbolInfo(name); var fieldSymbol = symbolInfo.Symbol as IFieldSymbol; if (fieldSymbol != null && fieldSymbol.DeclaredAccessibility == Accessibility.Private && !fieldSymbol.IsConst && !fieldSymbol.IsStatic) { name = name .WithIdentifier(SyntaxFactory.Identifier(GetChangedName(name.Identifier.ValueText))) .WithLeadingTrivia(name.GetLeadingTrivia()) .WithTrailingTrivia(name.GetTrailingTrivia()); } return(name); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { // Get related symbol ISymbol symbol = this.model.GetSymbolInfo(node).Symbol; // Check does the symbol refer to stored parameter if (symbol != null && symbol.Equals(this.parameterSymbol)) { // Create reference to temporary variable IdentifierNameSyntax tempVariableReference = Syntax.IdentifierName(this.variableName) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()); // Check is the IdentifierNameExpression on the left side of binary expression if (node.Parent != null && node.Parent is BinaryExpressionSyntax) { BinaryExpressionSyntax binaryExpression = (BinaryExpressionSyntax)node.Parent; if (IsComplexAssignment(binaryExpression) && binaryExpression.Left != null && binaryExpression.Left.Equals(node)) { // Assignment operation is rewritten to utilize new temporary variable return(tempVariableReference); } } // Verify has the parameter symbol been already assigned new value // If not, then no replacement should take place (we can still read the original value directly from parameter) StatementSyntax parentStatement = node.FirstAncestorOrSelf <StatementSyntax>(); if (IsInConditionExpression(parentStatement, this.parameterSymbol)) { return(tempVariableReference); } if (IsAlreadyAssignedNewValue(parentStatement, this.parameterSymbol)) { return(tempVariableReference); } } return(base.VisitIdentifierName(node)); }
private async Task <Document> ReplaceDateTimeAsync(Document document, IdentifierNameSyntax oldIdentifier, CancellationToken cancellationToken) { // Get the root syntax node for the current document var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false); // Create a new syntax node var newIdentifier = oldIdentifier.WithIdentifier( SyntaxFactory.ParseToken(nameof(DateTimeOffset)) .WithLeadingTrivia(oldIdentifier.GetLeadingTrivia()) .WithTrailingTrivia(oldIdentifier.GetTrailingTrivia())); // Create a new root syntax node for the current document replacing // the syntax node that has diagnostic with a new syntax node var newRoot = root.ReplaceNode(oldIdentifier, newIdentifier); // Generate a new document var newDocument = document.WithSyntaxRoot(newRoot); return(newDocument); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbolInfo = _semanticModel.GetSymbolInfo(node); if (symbolInfo.Symbol != null && symbolInfo.Symbol.Equals(_parameter)) { var replacement = _replaceWith; if (node.HasLeadingTrivia) { replacement = replacement.WithLeadingTrivia(node.GetLeadingTrivia()); } if (node.HasTrailingTrivia) { replacement = replacement.WithTrailingTrivia(node.GetTrailingTrivia()); } return(replacement); } return(base.VisitIdentifierName(node)); }
public override SyntaxNode Visit(SyntaxNode node) { if (node != null) { if (node is FieldDeclarationSyntax) { FieldDeclarationSyntax declarationSyntax = (FieldDeclarationSyntax)node; if (declarationSyntax.Declaration.Type is IdentifierNameSyntax) { IdentifierNameSyntax id = (IdentifierNameSyntax)declarationSyntax.Declaration.Type; String name = id.Identifier.ValueText; if (!SharedContainer.Instance.nameType.ContainsKey(name)) { return(node); } } } if (node is ParameterSyntax) { ParameterSyntax parameterSyntax = (ParameterSyntax)node; if (parameterSyntax.Type is IdentifierNameSyntax) { IdentifierNameSyntax id = (IdentifierNameSyntax)parameterSyntax.Type; String name = id.Identifier.ValueText; if (!SharedContainer.Instance.nameType.ContainsKey(name)) { return(node); } } } if (node is IdentifierNameSyntax) { IdentifierNameSyntax oldNode = (IdentifierNameSyntax)node; string name = oldNode.Identifier.ValueText; if (SharedContainer.Instance.nameMap.ContainsKey(name)) { IdentifierNameSyntax newNode = oldNode.WithIdentifier(Identifier(SharedContainer.Instance.nameMap[name])).WithLeadingTrivia(oldNode.GetLeadingTrivia()).WithTrailingTrivia(oldNode.GetTrailingTrivia()); return(node.ReplaceNode(oldNode, newNode)); } } if (node is ForEachStatementSyntax) { ForEachStatementSyntax oldNode = (ForEachStatementSyntax)node; string name = oldNode.Identifier.ValueText; if (SharedContainer.Instance.nameMap.ContainsKey(name)) { ForEachStatementSyntax newNode = oldNode.WithIdentifier(Identifier(SharedContainer.Instance.nameMap[name] + " ")); return(base.Visit(node.ReplaceNode(oldNode, newNode))); } } return(base.Visit(node)); } return(base.Visit(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { // Get related symbol CommonSymbolInfo symbolInfo = this.model.GetSymbolInfo(node, this.cancellationToken); ISymbol referencedSymbol = symbolInfo.Symbol; // Do not consider identifiers within NameColonSyntax! if (referencedSymbol != null && !(node.Parent is NameColonSyntax)) { // Verify does the name refer to any of compressed parameters if (this.symbols.Contains(referencedSymbol)) { // Replace parameter reference with reference via ParameterObject // Considers: // int a = b; -> int a = parameterObject.b; MemberAccessExpressionSyntax accessExpression = Syntax.MemberAccessExpression( SyntaxKind.MemberAccessExpression, Syntax.IdentifierName(this.parameterObjectName), Syntax.IdentifierName(node.Identifier.WithLeadingTrivia()) ) .WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()); return(accessExpression); } } // Perform default behavior return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { ISymbol symbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol; if (symbol.Kind == CommonSymbolKind.Parameter) { ParameterSymbol parameterSymbol = (ParameterSymbol)symbol; ExpressionSyntax mappedExpression = this.map[parameterSymbol]; ExpressionSyntax inlinedExpression = mappedExpression; // If argument type is different than method's parameter type, additional cast is needed ITypeSymbol parameterType = parameterSymbol.Type; ITypeSymbol argumentType = this.model.GetTypeInfo(mappedExpression, this.cancellationToken).Type; // TODO: If this is generic type, i.e. IList<T>, visit its identifiers if (parameterType.Kind == CommonSymbolKind.NamedType && ((NamedTypeSymbol)parameterType).IsGenericType) { } // If parameter type is TypeParameter (template parameter), then it is same as argument type if (parameterType.Kind == CommonSymbolKind.TypeParameter) { parameterType = argumentType; } bool castInlinedExpression = false; if (!parameterType.Equals(argumentType)) { castInlinedExpression = true; } SyntaxNode parentNode = node.Parent; if (mappedExpression.Kind != SyntaxKind.ParenthesizedExpression) { // Surround with parenthesis if required if ((mappedExpression is BinaryExpressionSyntax || mappedExpression is ConditionalExpressionSyntax) && (parentNode is BinaryExpressionSyntax || castInlinedExpression || parentNode.Kind == SyntaxKind.MemberAccessExpression) ) { inlinedExpression = Syntax.ParenthesizedExpression(inlinedExpression); } } // Cast expression to preserve type semantics if necessary if (castInlinedExpression) { TypeSyntax typeSyntax = Syntax.ParseTypeName(parameterType.ToMinimalDisplayString(node.GetLocation(), this.model)); inlinedExpression = Syntax.CastExpression(typeSyntax, inlinedExpression); // If inlined expression is used in a context with operator of higher precedence than cast operator, then again parenthesis is needed // Considers: // a[0] -> >(< (IList<int>)a >)< [0] , not (IList<int>)a[0] // a.b -> >(< (A)a >)< .b , not (A)a.b // a++ -> >(< (A)a >)< ++ , not (A)a++ if (parentNode.Kind == SyntaxKind.ElementAccessExpression || parentNode.Kind == SyntaxKind.MemberAccessExpression || parentNode.Kind == SyntaxKind.PostDecrementExpression || parentNode.Kind == SyntaxKind.PostIncrementExpression) { inlinedExpression = Syntax.ParenthesizedExpression(inlinedExpression); } } inlinedExpression = inlinedExpression.WithLeadingTrivia(node.GetLeadingTrivia()) .WithTrailingTrivia(node.GetTrailingTrivia()); return(inlinedExpression); } else if (symbol.Kind == CommonSymbolKind.TypeParameter) { // TypeParameter identifier is replaced with actual type in target scope // Considers: // T foo<T>() { return (T)1; } // foo<int>() -> (int)1; TypeParameterSymbol typeParameterSymbol = (TypeParameterSymbol)symbol; TypeSymbol actualTypeSymbol = mapTypeParameters[typeParameterSymbol]; IdentifierNameSyntax newIdentifier = Syntax.IdentifierName(actualTypeSymbol.ToMinimalDisplayString(node.GetLocation(), this.model)); return(newIdentifier); } return(base.VisitIdentifierName(node)); }
public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node) { var symbol = semanticModel.GetSymbolInfo(node).Symbol; var parent = node.Parent; while (parent != null && !(parent is TypeDeclarationSyntax)) { parent = parent.Parent; } ITypeSymbol thisType = null; if (parent is TypeDeclarationSyntax) { thisType = this.semanticModel.GetDeclaredSymbol(parent) as ITypeSymbol; } bool needHandle = !node.IsVar && symbol is ITypeSymbol && symbol.ContainingType != null && thisType != null && !thisType.InheritsFromOrEquals(symbol.ContainingType) && !thisType.Equals(symbol); var qns = node.Parent as QualifiedNameSyntax; if (qns != null && needHandle) { SyntaxNode n = node; do { if (!qns.Left.Equals(n)) { needHandle = false; } n = qns; qns = qns.Parent as QualifiedNameSyntax; } while (qns != null && needHandle); } node = (IdentifierNameSyntax)base.VisitIdentifierName(node); if (needHandle && !(node.Parent is MemberAccessExpressionSyntax)) { INamedTypeSymbol namedType = symbol as INamedTypeSymbol; if (namedType != null && namedType.IsGenericType && namedType.TypeArguments.Length > 0 && !namedType.TypeArguments.Any(SyntaxHelper.IsAnonymous)) { var genericName = SyntaxHelper.GenerateGenericName(node.Identifier, namedType.TypeArguments); return(genericName.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia())); } return(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(node.GetLeadingTrivia(), symbol.FullyQualifiedName(), node.GetTrailingTrivia()))); } IMethodSymbol methodSymbol = null; if (symbol != null && symbol.IsStatic && symbol.ContainingType != null && thisType != null && !thisType.InheritsFromOrEquals(symbol.ContainingType) && !(node.Parent is MemberAccessExpressionSyntax) && ( (methodSymbol = symbol as IMethodSymbol) != null || symbol is IPropertySymbol || symbol is IFieldSymbol || symbol is IEventSymbol) ) { if (methodSymbol != null && methodSymbol.IsGenericMethod && methodSymbol.TypeArguments.Length > 0 && !methodSymbol.TypeArguments.Any(SyntaxHelper.IsAnonymous)) { var genericName = SyntaxHelper.GenerateGenericName(node.Identifier, methodSymbol.TypeArguments); return(genericName.WithLeadingTrivia(node.GetLeadingTrivia()).WithTrailingTrivia(node.GetTrailingTrivia())); } return(SyntaxFactory.IdentifierName(SyntaxFactory.Identifier(node.GetLeadingTrivia(), symbol.FullyQualifiedName(), node.GetTrailingTrivia()))); } return(node); }
public override SyntaxNode VisitInvocationExpression(InvocationExpressionSyntax node) { ExpressionSyntax expression = node.Expression; CommonSymbolInfo methodSymbolInfo = this.model.GetSymbolInfo(expression); MethodSymbol visitedMethodSymbol = methodSymbolInfo.Symbol as MethodSymbol; // Verify does the invocation refer to searched method if (visitedMethodSymbol != null && visitedMethodSymbol.Equals(this.methodSymbol)) { if (expression.Kind == SyntaxKind.MemberAccessExpression) { MemberAccessExpressionSyntax memberAccess = (MemberAccessExpressionSyntax)expression; // Move all from the beginning (except for the method name) to parameter // Considers: // a.b.foo(47); -> B.foo(a.b, 47); ArgumentListSyntax argumentsList = node.ArgumentList; ArgumentSyntax newArgument = Syntax.Argument(memberAccess.Expression); SeparatedSyntaxList <ArgumentSyntax> arguments = argumentsList.Arguments.Insert(0, newArgument); argumentsList = Syntax.ArgumentList(arguments).WithAdditionalAnnotations(CodeAnnotations.Formatting); InvocationExpressionSyntax newInvocation = node.WithArgumentList(argumentsList); // Replace invocation expression with qualified (class) name TypeSyntax typeSyntax = Syntax.ParseTypeName(this.methodSymbol.ContainingType.ToMinimalDisplayString(expression.GetLocation(), this.model)) .WithLeadingTrivia(memberAccess.Expression.GetLeadingTrivia()); newInvocation = newInvocation.WithExpression(Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, typeSyntax, memberAccess.Name)); return(newInvocation); } else if (expression.Kind == SyntaxKind.IdentifierName) { IdentifierNameSyntax identifierName = (IdentifierNameSyntax)expression; // Unqualified reference, `this' should be passed as first parameter // Considers: // foo(47); -> B.foo(this, 47); ArgumentListSyntax argumentsList = node.ArgumentList; ArgumentSyntax newArgument = Syntax.Argument(Syntax.ThisExpression()); SeparatedSyntaxList <ArgumentSyntax> arguments = argumentsList.Arguments.Insert(0, newArgument); argumentsList = Syntax.ArgumentList(arguments).WithAdditionalAnnotations(CodeAnnotations.Formatting); InvocationExpressionSyntax newInvocation = node.WithArgumentList(argumentsList); // Replace invocation expression with qualified (class) name TypeSyntax typeSyntax = Syntax.ParseTypeName(this.methodSymbol.ContainingType.ToMinimalDisplayString(expression.GetLocation(), this.model)) .WithLeadingTrivia(identifierName.GetLeadingTrivia()); newInvocation = newInvocation.WithExpression(Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, typeSyntax, identifierName)); return(newInvocation); } } return(base.VisitInvocationExpression(node)); }