public override SyntaxNode VisitIdentifierName(IdentifierNameSyntax node)
{
IdentifierNameSyntax processedNode = (IdentifierNameSyntax)base.VisitIdentifierName(node);
ISymbol symbol = this.model.GetSymbolInfo(node, this.cancellationToken).Symbol;
// If this is reference to renamed symbol, replace identifier
if (this.renamedSymbol.Equals(symbol))
{
SyntaxToken identifier = node.Identifier;
SyntaxToken newIdentifier = Syntax.Identifier(identifier.LeadingTrivia, this.newName, identifier.TrailingTrivia);
IdentifierNameSyntax newIdentifierName = processedNode.WithIdentifier(newIdentifier);
return newIdentifierName;
}
else if (node.Identifier.ValueText == this.newName)
{
// If the Identifier refers to type name within variable declaration, no action is undertaken
// Consider:
// newVariableName myVariable; -> type name can remain as is
if (node.Ancestors().OfType<VariableDeclarationSyntax>().Any(n => n.Type.DescendantNodesAndSelf().Contains(node)))
{
return processedNode;
}
// If it is not a top-most expression of MemberAccessExpression, don't qualify
if (node.Ancestors().OfType<MemberAccessExpressionSyntax>().Any(n => n.Name.DescendantNodesAndSelf().Contains(node)))
{
return processedNode;
}
ExpressionSyntax qualifier = null;
if (symbol.IsStatic)
{
// If symbol is static, qualify the reference with containing type's name
qualifier = Syntax.ParseTypeName(symbol.ContainingType.ToMinimalDisplayString(node.GetLocation(), this.model));
}
else
{
// If symbol is instance, qualify the reference with `this' keyword
qualifier = Syntax.ThisExpression();
}
MemberAccessExpressionSyntax memberAccess = Syntax.MemberAccessExpression(SyntaxKind.MemberAccessExpression, qualifier, processedNode);
return memberAccess;
}
return processedNode;
}
static public Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > GetIdentifierDeclarationSyntax(IdentifierNameSyntax syntax, MethodBlockAnalysis methodAnalysis)
{
Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Ok(IXor4IdentifierOriginSyntax ok) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(ok);
Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Error(SimpleControlFlowAnalysisError error) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(error);
var loopLikeSyntax = syntax.Ancestors().FirstOrDefault(x => SyntaxOperations.IsLoopLike(x));
if (loopLikeSyntax != null)
{
return(__Error(SimpleControlFlowAnalysisError.NotALinearControlFlow(loopLikeSyntax)));
}
else
{
var symbolInfo = methodAnalysis.SemanticModel.GetSymbolInfo(syntax);
switch (symbolInfo.Symbol.Kind)
{
case SymbolKind.NamedType:
case SymbolKind.Namespace:
{
return(Maybe.NoValue);
}
case SymbolKind.Local:
{
var declaratorSyntax = (VariableDeclaratorSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
var delarationSyntax = declaratorSyntax.Ancestors().OfType <LocalDeclarationStatementSyntax>().First();
return(__Ok(new Xor4IdentifierOriginSyntax(delarationSyntax)));
}
case SymbolKind.Field:
{
var declaringSyntax = (FieldDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
case SymbolKind.Property:
{
var declaringSyntax = (PropertyDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
case SymbolKind.Parameter:
{
var declaringSyntax = (ParameterSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
default:
throw NotPreparedForThatCase.UnexpectedEnumException(symbolInfo.Symbol.Kind);
}
}
}
private static bool HasConflict(
IdentifierNameSyntax identifier,
VariableDeclaratorSyntax variableDeclarator
)
{
// TODO: Check for more conflict types.
if (identifier.SpanStart < variableDeclarator.SpanStart)
{
return(true);
}
var identifierNode = identifier
.Ancestors()
.TakeWhile(
n =>
n.Kind() == SyntaxKind.ParenthesizedExpression ||
n.Kind() == SyntaxKind.CastExpression
)
.LastOrDefault();
if (identifierNode == null)
{
identifierNode = identifier;
}
if (identifierNode.IsParentKind(SyntaxKind.Argument, out ArgumentSyntax argument))
{
if (argument.RefOrOutKeyword.Kind() != SyntaxKind.None)
{
return(true);
}
}
else if (
identifierNode.Parent.IsKind(
SyntaxKind.PreDecrementExpression,
SyntaxKind.PreIncrementExpression,
SyntaxKind.PostDecrementExpression,
SyntaxKind.PostIncrementExpression,
SyntaxKind.AddressOfExpression
)
)
{
return(true);
}
else if (identifierNode.Parent is AssignmentExpressionSyntax binaryExpression)
{
if (binaryExpression.Left == identifierNode)
{
return(true);
}
}
return(false);
}
public override void VisitIdentifierName(IdentifierNameSyntax node)
{
base.VisitIdentifierName(node);
var ancestors = node.Ancestors();
if (ancestors.Any(n => (n is MemberAccessExpressionSyntax) || (n is InvocationExpressionSyntax)))
{
return;
}
Check(node);
}
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 Task <Solution> CreateRecordAttributeDeclarationDocument(Document document, IdentifierNameSyntax declaration, CancellationToken cancellationToken)
{
// get the namespace of document or namespace from attribute usage
var namespaces = declaration
.Ancestors()
.OfType <NamespaceDeclarationSyntax>()
.Reverse()
.Select(nsSyntax => nsSyntax.Name.ToString())
.ToArray();
var targetNamespace = string.Join(".", namespaces);
var text = RecordAttributeDeclarationSource(targetNamespace);
var tree = CSharpSyntaxTree.ParseText(text, cancellationToken: cancellationToken);
var formattedRoot = Formatter.Format(tree.GetRoot(), document.Project.Solution.Workspace, cancellationToken: cancellationToken);
var doc = document.Project.AddDocument(RecordAttributeProperties.Filename, formattedRoot, document.Folders);
return(Task.FromResult(doc.Project.Solution));
}
