private static IdentifierNameSyntax PadMemberAccess(
SimpleLambdaExpressionSyntax node,
IdentifierNameSyntax memberAccess)
{
// We want to make the new span
var originalSpan = node.GetLocation().GetMappedLineSpan();
// Start by collecting all the trivia 'inside' the expression - we need to tack that on the end, but
// if it ends with a newline, don't include that.
var innerTrivia = SyntaxFactory.TriviaList(node.DescendantTrivia(descendIntoChildren: n => true));
if (innerTrivia.Count > 0 && innerTrivia[innerTrivia.Count - 1].IsKind(SyntaxKind.EndOfLineTrivia))
{
innerTrivia = innerTrivia.RemoveAt(innerTrivia.Count - 1);
}
memberAccess = memberAccess.WithTrailingTrivia(innerTrivia);
// If everything is all on one line, then make sure the spans are the same, to compensate
// for the expression potentially being longer than the variable name.
var lineSpan = originalSpan.EndLinePosition.Line - originalSpan.StartLinePosition.Line;
if (lineSpan == 0)
{
var padding = node.Span.Length - memberAccess.FullSpan.Length;
var trailingTrivia =
SyntaxFactory.TriviaList(memberAccess.GetTrailingTrivia())
.Add(SyntaxFactory.Whitespace(new string(' ', padding)))
.AddRange(node.GetTrailingTrivia());
return
(memberAccess
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(trailingTrivia));
}
else
{
// If everything isn't on the same line, we need to pad out the last line.
var padding =
originalSpan.EndLinePosition.Character -
originalSpan.StartLinePosition.Character;
var trailingTrivia =
SyntaxFactory.TriviaList(memberAccess.GetTrailingTrivia())
.Add(SyntaxFactory.Whitespace(new string(' ', padding)))
.AddRange(node.GetTrailingTrivia());
return
(memberAccess
.WithLeadingTrivia(node.GetLeadingTrivia())
.WithTrailingTrivia(trailingTrivia));
}
}
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)
{
if (_nodes.Contains(node))
{
node = IdentifierName(_methodName).WithTriviaFrom(node);
return(InvocationExpression(
node.WithoutTrailingTrivia(),
ArgumentList().WithTrailingTrivia(node.GetTrailingTrivia())));
}
return(base.VisitIdentifierName(node));
}
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);
}
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 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)
{
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 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;
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);
}
