public RunCodeIssuesResponse FixCodeIssue(Request req)
{
var issues = GetContextualCodeActions(req).ToList();
var issue = issues.FirstOrDefault(i => i.Start.Line == req.Line);
if (issue == null)
{
return new RunCodeIssuesResponse {
Text = req.Buffer
}
}
;
var context = OmniSharpRefactoringContext.GetContext(_bufferParser, req);
using (var script = new OmniSharpScript(context, _config))
{
var action = issue.Actions.FirstOrDefault();
if (action != null)
{
action.Run(script);
return(new RunCodeIssuesResponse {
Text = context.Document.Text
});
}
}
return(new RunCodeIssuesResponse {
Text = req.Buffer
});
}
/// <summary>
/// Inserts the given EntityDeclaration with the given
/// script at the end of the type declaration under the
/// cursor (e.g. class / struct).
/// </summary>
/// <remarks>
/// Alters the given script. Returns its CurrentDocument
/// property. Alters the given memberDeclaration, adding
/// Modifiers.Override to its Modifiers as well as removing
/// Modifiers.Virtual.
/// </remarks>
IDocument runOverrideTargetWorker
(Request request
, OmniSharpRefactoringContext refactoringContext
, ParsedResult parsedContent
, EntityDeclaration memberDeclaration
, OmniSharpScript script)
{
// Add override flag
memberDeclaration.Modifiers |= Modifiers.Override;
// Remove virtual flag
memberDeclaration.Modifiers &= ~Modifiers.Virtual;
// Remove abstract flag
memberDeclaration.Modifiers &= ~Modifiers.Abstract;
// The current type declaration, e.g. class, struct..
var typeDeclaration = parsedContent.SyntaxTree.GetNodeAt
(refactoringContext.Location
, n => n.NodeType == NodeType.TypeDeclaration);
// Even empty classes have nodes, so this works
var lastNode =
typeDeclaration.Children.Last();
script.InsertBefore
(node: lastNode
, newNode: memberDeclaration);
script.FormatText(memberDeclaration);
return(script.CurrentDocument);
}
string AddUsingLinq(AstNode astNode, string buffer)
{
var request = CreateRequest(buffer, astNode);
var context = OmniSharpRefactoringContext.GetContext(_bufferParser, request);
var script = new OmniSharpScript(context, _config);
UsingHelper.InsertUsingAndRemoveRedundantNamespaceUsage(context, script, "System.Linq");
return(context.Document.Text);
}
public FixUsingsResponse FixUsings(Request request)
{
_fileName = request.FileName;
string buffer = RemoveUsings(request.Buffer);
buffer = SortUsings(buffer);
buffer = AddLinqForQueryIfMissing(buffer);
bool ambiguousResultsFound = false;
bool usingsAdded = true;
while (usingsAdded)
{
var content = _bufferParser.ParsedContent(buffer, _fileName);
var tree = content.SyntaxTree;
var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile);
var unresolvedNodes = GetAllUnresolvedNodes(tree, resolver).Select(nr => GetNodeToAddUsing(nr));
usingsAdded = false;
request.Buffer = buffer;
var outerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, request);
using (var script = new OmniSharpScript(outerContext, _config))
{
foreach (var unresolvedNode in unresolvedNodes)
{
_logger.Info(unresolvedNode);
var requestForNode = CreateRequest(buffer, unresolvedNode);
var innerContext = OmniSharpRefactoringContext.GetContext(_bufferParser, requestForNode);
var addUsingAction = new AddUsingAction();
var actions = addUsingAction.GetActions(innerContext).Where(a => a.Description.StartsWith("using")).ToArray();
if (actions.Length == 1)
{
var a = actions[0];
_logger.Info("Adding " + a.Description);
a.Run(script);
usingsAdded = true;
break;
}
ambiguousResultsFound |= actions.Length > 1;
}
}
buffer = outerContext.Document.Text;
}
IEnumerable <QuickFix> ambiguous = Enumerable.Empty <QuickFix>();
if (ambiguousResultsFound)
{
ambiguous = GetAmbiguousNodes(buffer, request.FileName);
}
return(new FixUsingsResponse(buffer, ambiguous));
}
string RunActions(OmniSharpRefactoringContext context, IEnumerable <CodeAction> actions)
{
using (var script = new OmniSharpScript(context, _config))
{
foreach (var action in actions)
{
if (action != null)
{
action.Run(script);
}
}
}
return(context.Document.Text);
}
public RunCodeActionsResponse RunCodeAction(CodeActionRequest req)
{
var actions = GetContextualCodeActions(req).ToList();
if (req.CodeAction > actions.Count)
{
return(new RunCodeActionsResponse());
}
var context = OmniSharpRefactoringContext.GetContext(_bufferParser, req);
using (var script = new OmniSharpScript(context, _config))
{
CodeAction action = actions[req.CodeAction];
action.Run(script);
}
return(new RunCodeActionsResponse {
Text = context.Document.Text
});
}
public RenameResponse Rename(RenameRequest req)
{
var project = _solution.ProjectContainingFile(req.FileName);
var syntaxTree = project.CreateParser().Parse(req.Buffer, req.FileName);
var sourceNode = syntaxTree.GetNodeAt(req.Line, req.Column);
if (sourceNode == null)
{
return(new RenameResponse());
}
IEnumerable <AstNode> nodes = _findUsagesHandler.FindUsageNodes(req).ToArray();
var response = new RenameResponse();
var modfiedFiles = new List <ModifiedFileResponse>();
response.Changes = modfiedFiles;
foreach (IGrouping <string, AstNode> groupedNodes in nodes.GroupBy(n => n.GetRegion().FileName.LowerCaseDriveLetter()))
{
string fileName = groupedNodes.Key;
OmniSharpRefactoringContext context;
if (groupedNodes.Key != req.FileName)
{
var file = _solution.GetFile(fileName);
var bufferParser = new BufferParser(_solution);
var content = bufferParser.ParsedContent(file.Document.Text, file.FileName);
var resolver = new CSharpAstResolver(content.Compilation, content.SyntaxTree, content.UnresolvedFile);
context = new OmniSharpRefactoringContext(file.Document, resolver);
}
else
{
context = OmniSharpRefactoringContext.GetContext(_bufferParser, req);
}
string modifiedBuffer = null;
var lastToFirstNodes = groupedNodes.OrderByDescending(n => n.EndLocation.Line)
.ThenByDescending(n => n.EndLocation.Column);
foreach (var node in lastToFirstNodes)
{
using (var script = new OmniSharpScript(context, _config))
{
script.Rename(node, req.RenameTo);
modifiedBuffer = script.CurrentDocument.Text;
}
}
if (modifiedBuffer != null)
{
var modifiedFile = new ModifiedFileResponse
{
FileName
= fileName,
Buffer = modifiedBuffer
};
modfiedFiles.Add(modifiedFile);
response.Changes = modfiedFiles;
_bufferParser.ParsedContent(modifiedBuffer, fileName);
_solution.ProjectContainingFile(fileName).UpdateFile(fileName, modifiedBuffer);
}
}
return(response);
}
