public IEnumerable <CodeAction> GetActions(RefactoringContext context)
{
if (context.IsSomethingSelected)
{
yield break;
}
var node = context.GetNode <VariableDeclarationStatement>();
if (node == null || node.Variables.Count != 1)
{
yield break;
}
var initializer = node.Variables.First();
if (!initializer.NameToken.Contains(context.Location) || initializer.Initializer.IsNull)
{
yield break;
}
var resolveResult = context.Resolve(initializer) as LocalResolveResult;
if (resolveResult == null || resolveResult.IsError)
{
yield break;
}
var unit = context.RootNode as SyntaxTree;
if (unit == null)
{
yield break;
}
yield return(new CodeAction(context.TranslateString("Inline local variable"), script => {
refFinder.FindLocalReferences(resolveResult.Variable, context.UnresolvedFile, unit, context.Compilation, (n, r) => script.Replace(n, AddParensIfRequired(n, initializer.Initializer.Clone())), default(CancellationToken));
script.Remove(node);
}, initializer));
}
void FindIssuesInNode(AstNode anchor, AstNode node, string accessorName = "setter")
{
if (node == null || node.IsNull)
{
return;
}
var localResolveResult = context.GetResolverStateBefore(node)
.LookupSimpleNameOrTypeName("value", new List <IType>(), NameLookupMode.Expression) as LocalResolveResult;
if (localResolveResult == null)
{
return;
}
var variable = localResolveResult.Variable;
bool referenceFound = false;
var findRef = new FindReferences();
var syntaxTree = (SyntaxTree)context.RootNode;
findRef.FindLocalReferences(variable, context.UnresolvedFile, syntaxTree, context.Compilation, (n, entity) => {
if (n.StartLocation >= node.StartLocation && n.EndLocation <= node.EndLocation)
{
referenceFound = true;
}
}, CancellationToken.None);
if (!referenceFound)
{
AddIssue(anchor, context.TranslateString("The " + accessorName + " does not use the 'value' parameter"));
}
}
bool HasDependency(RefactoringContext context, AstNode firstSearchNode, AstNode targetNode)
{
var referenceFinder = new FindReferences();
var identifiers = targetNode.Descendants
.Where(n => n is IdentifierExpression)
.Select <AstNode, IdentifierExpression>(node => (IdentifierExpression)node);
foreach (var identifier in identifiers)
{
var resolveResult = context.Resolve(identifier);
var localResolveResult = resolveResult as LocalResolveResult;
if (localResolveResult == null)
{
continue;
}
bool referenceFound = false;
// var variable = localResolveResult.Variable;
var syntaxTree = context.RootNode as SyntaxTree;
referenceFinder.FindLocalReferences(localResolveResult.Variable, context.UnresolvedFile, syntaxTree,
context.Compilation, (node, nodeResolveResult) => {
if (node.StartLocation > firstSearchNode.StartLocation && node.EndLocation < targetNode.StartLocation)
{
referenceFound = true;
}
}, CancellationToken.None);
if (referenceFound)
{
return(true);
}
}
return(false);
}
protected static bool TestOnlyAssigned(BaseRefactoringContext ctx, SyntaxTree unit, IVariable variable)
{
var assignment = false;
var nonAssignment = false;
refFinder.FindLocalReferences(variable, ctx.UnresolvedFile, unit, ctx.Compilation,
(node, resolveResult) =>
{
if (node is ParameterDeclaration)
{
return;
}
if (node is VariableInitializer)
{
if (!(node as VariableInitializer).Initializer.IsNull)
{
assignment = true;
}
return;
}
if (node is IdentifierExpression)
{
var parent = node.Parent;
if (parent is AssignmentExpression)
{
if (((AssignmentExpression)parent).Left == node)
{
assignment = true;
return;
}
}
else if (parent is UnaryOperatorExpression)
{
var op = ((UnaryOperatorExpression)parent).Operator;
switch (op)
{
case UnaryOperatorType.Increment:
case UnaryOperatorType.PostIncrement:
case UnaryOperatorType.Decrement:
case UnaryOperatorType.PostDecrement:
assignment = true;
return;
}
}
else if (parent is DirectionExpression)
{
if (((DirectionExpression)parent).FieldDirection == FieldDirection.Out)
{
assignment = true;
return;
}
}
}
nonAssignment = true;
}, ctx.CancellationToken);
return(assignment && !nonAssignment);
}
void Rename(IVariable variable, string name)
{
FindReferences refFinder = new FindReferences();
refFinder.FindLocalReferences(variable,
context.UnresolvedFile,
context.RootNode as SyntaxTree,
context.Compilation, (n, r) => Rename(n, name),
context.CancellationToken);
}
public override void Rename(IVariable variable, string name)
{
FindReferences refFinder = new FindReferences();
refFinder.FindLocalReferences(variable,
context.ParsedFile,
context.RootNode as CompilationUnit,
context.Compilation, (n, r) => Rename(n, name),
context.CancellationToken);
}
bool HasDependencyCheck(FindReferences referenceFinder, LocalResolveResult localResolveResult)
{
bool result = false;
referenceFinder.FindLocalReferences(localResolveResult.Variable, context.UnresolvedFile,
(SyntaxTree)context.RootNode, context.Compilation,
(node, resolveResult) => {
result |= VariableHasBeenConverted(localResolveResult.Variable);
}, CancellationToken.None);
return(result);
}
bool IsReferenced(IVariable variable, AstNode node, SyntaxTree syntaxTree, RefactoringContext context)
{
int referencesFound = 0;
var findRef = new FindReferences();
findRef.FindLocalReferences(variable, context.UnresolvedFile, syntaxTree, context.Compilation, (n, entity) => {
referencesFound++;
}, CancellationToken.None);
// One reference is the declaration, and that does not count
return referencesFound > 1;
}
protected static bool FindUsage(BaseRefactoringContext context, SyntaxTree unit, IVariable variable,
AstNode declaration)
{
var found = false;
refFinder.FindLocalReferences(variable, context.UnresolvedFile, unit, context.Compilation,
(node, resolveResult) =>
{
found = found || node != declaration;
}, context.CancellationToken);
return(found);
}
static AstNode GetLastReference(IVariable variable, RefactoringContext context, SyntaxTree unit)
{
AstNode lastReference = null;
refFinder.FindLocalReferences(variable, context.UnresolvedFile, unit, context.Compilation,
(v, r) =>
{
if (lastReference == null || v.EndLocation > lastReference.EndLocation)
{
lastReference = v;
}
}, context.CancellationToken);
return(lastReference);
}
private List <AstNode> GetResolvedNodes(ResolveResultType type, AstNode node)
{
var resolvedNodes = new List <AstNode>();
ResolveResult resolveResult = _resolver.Resolve(node);
if (resolveResult != null)
{
var findReferences = new FindReferences();
FoundReferenceCallback callback = delegate(AstNode matchNode, ResolveResult result)
{
resolvedNodes.Add(matchNode);
};
if (type == ResolveResultType.Local)
{
var localResolveResult = resolveResult as LocalResolveResult;
if (localResolveResult != null)
{
findReferences.FindLocalReferences(localResolveResult.Variable, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
else if (type == ResolveResultType.Member)
{
var memberResolveResult = resolveResult as MemberResolveResult;
if (memberResolveResult != null)
{
var searchScopes = findReferences.GetSearchScopes(memberResolveResult.Member);
findReferences.FindReferencesInFile(searchScopes, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
else if (type == ResolveResultType.Type)
{
var typeResolveResult = resolveResult as TypeResolveResult;
if (typeResolveResult != null)
{
var searchScopes = findReferences.GetSearchScopes(typeResolveResult.Type.GetDefinition());
findReferences.FindReferencesInFile(searchScopes, _unresolvedFile, SyntaxTree, _compilation, callback, CancellationToken.None);
}
}
}
else
{
}
return(resolvedNodes);
}
Dictionary <VariableReferenceNode, int> nodeDegree; // number of enumerations a node can reach
void FindReferences(AstNode variableDecl, IVariable variable)
{
references = new HashSet <AstNode> ();
refStatements = new HashSet <Statement> ();
lambdaExpressions = new HashSet <LambdaExpression> ();
refFinder.FindLocalReferences(variable, ctx.UnresolvedFile, unit, ctx.Compilation,
(astNode, resolveResult) => {
if (astNode == variableDecl)
{
return;
}
var parent = astNode.Parent;
while (!(parent == null || parent is Statement || parent is LambdaExpression))
{
parent = parent.Parent;
}
if (parent == null)
{
return;
}
// lambda expression with expression body, should be analyzed separately
var expr = parent as LambdaExpression;
if (expr != null)
{
if (IsAssignment(astNode) || IsEnumeration(astNode))
{
references.Add(astNode);
lambdaExpressions.Add(expr);
}
return;
}
var statement = (Statement)parent;
if (IsAssignment(astNode) || IsEnumeration(astNode))
{
references.Add(astNode);
refStatements.Add(statement);
}
}, ctx.CancellationToken);
}
public IEnumerable <AstNode> FindUsageNodes(Request request)
{
var res = _parser.ParsedContent(request.Buffer, request.FileName);
var loc = new TextLocation(request.Line, request.Column);
_result = new ConcurrentBag <AstNode>();
var findReferences = new FindReferences
{
FindCallsThroughInterface = true,
FindCallsThroughVirtualBaseMethod = true,
FindTypeReferencesEvenIfAliased = true,
};
ResolveResult resolveResult = ResolveAtLocation.Resolve(res.Compilation, res.UnresolvedFile, res.SyntaxTree, loc);
if (resolveResult is LocalResolveResult)
{
var variable = (resolveResult as LocalResolveResult).Variable;
findReferences.FindLocalReferences(variable, res.UnresolvedFile, res.SyntaxTree, res.Compilation,
(node, rr) => _result.Add(node.GetDefinition()), CancellationToken.None);
}
else
{
IEntity entity = null;
IEnumerable <IList <IFindReferenceSearchScope> > searchScopes = null;
if (resolveResult is TypeResolveResult)
{
var type = (resolveResult as TypeResolveResult).Type;
entity = type.GetDefinition();
ProcessTypeResults(type);
searchScopes = new[] { findReferences.GetSearchScopes(entity) };
}
if (resolveResult is MemberResolveResult)
{
entity = (resolveResult as MemberResolveResult).Member;
if (entity.EntityType == EntityType.Constructor)
{
// process type instead
var type = entity.DeclaringType;
entity = entity.DeclaringTypeDefinition;
ProcessTypeResults(type);
searchScopes = new[] { findReferences.GetSearchScopes(entity) };
}
else
{
ProcessMemberResults(resolveResult);
var members = MemberCollector.CollectMembers(_solution,
(resolveResult as MemberResolveResult).Member);
searchScopes = members.Select(findReferences.GetSearchScopes);
}
}
if (entity == null)
{
return(_result);
}
var interesting = new List <CSharpUnresolvedFile>();
foreach (var project in _solution.Projects)
{
var pctx = project.ProjectContent.CreateCompilation();
interesting = (from file in project.Files
select(file.ParsedFile as CSharpUnresolvedFile)).ToList();
foreach (var file in interesting)
{
string text = _solution.GetFile(file.FileName).Content.Text;
var unit = new CSharpParser().Parse(text, file.FileName);
foreach (var scope in searchScopes)
{
findReferences.FindReferencesInFile(scope, file, unit,
pctx,
(node, rr) => _result.Add(node.GetIdentifier()),
CancellationToken.None);
}
}
}
}
return(_result);
}
void CollectIssues(AstNode variableDecl, BlockStatement rootStatement, LocalResolveResult resolveResult)
{
if (rootStatement == null || resolveResult == null)
{
return;
}
var references = new HashSet <AstNode> ();
var refStatements = new HashSet <Statement> ();
var usedInLambda = false;
refFinder.FindLocalReferences(resolveResult.Variable, ctx.UnresolvedFile, unit, ctx.Compilation,
(astNode, rr) => {
if (usedInLambda || astNode == variableDecl)
{
return;
}
var parent = astNode.Parent;
while (!(parent == null || parent is Statement || parent is LambdaExpression))
{
parent = parent.Parent;
}
if (parent == null)
{
return;
}
var statement = parent as Statement;
if (statement != null)
{
references.Add(astNode);
refStatements.Add(statement);
}
while (parent != null && parent != rootStatement)
{
if (parent is LambdaExpression || parent is AnonymousMethodExpression)
{
usedInLambda = true;
break;
}
parent = parent.Parent;
}
}, ctx.CancellationToken);
// stop analyzing if the variable is used in any lambda expression or anonymous method
if (usedInLambda)
{
return;
}
var startNode = VariableReferenceGraphBuilder.Build(rootStatement, references, refStatements, ctx);
var variableInitializer = variableDecl as VariableInitializer;
if (variableInitializer != null && !variableInitializer.Initializer.IsNull)
{
startNode.References.Insert(0, variableInitializer);
}
ProcessNodes(startNode);
}
