TextLocation GetEndOfPrev(AstNode node)
{
do {
node = node.GetPrevNode();
} while (node.NodeType == NodeType.Whitespace);
return node.EndLocation;
}
TextLocation GetEndOfPrev(AstNode node)
{
do
{
node = node.GetPrevNode();
} while (node.NodeType == NodeType.Whitespace);
return(node.EndLocation);
}
static FormattingChanges GetFormattingChanges(PolicyContainer policyParent, IEnumerable <string> mimeTypeChain, MonoDevelop.Ide.Gui.Document document, string input, DomRegion formattingRegion, ref int formatStartOffset, ref int formatLength, bool formatLastStatementOnly)
{
using (var stubData = TextEditorData.CreateImmutable(input)) {
stubData.Document.FileName = document.FileName;
var parser = document.HasProject ? new CSharpParser(TypeSystemParser.GetCompilerArguments(document.Project)) : new CSharpParser();
var compilationUnit = parser.Parse(stubData);
bool hadErrors = parser.HasErrors;
if (hadErrors)
{
using (var stubData2 = TextEditorData.CreateImmutable(input + "}")) {
compilationUnit = parser.Parse(stubData2);
hadErrors = parser.HasErrors;
}
}
// try it out, if the behavior is better when working only with correct code.
if (hadErrors)
{
return(null);
}
var policy = policyParent.Get <CSharpFormattingPolicy> (mimeTypeChain);
var formattingVisitor = new ICSharpCode.NRefactory.CSharp.CSharpFormatter(policy.CreateOptions(), document.Editor.CreateNRefactoryTextEditorOptions());
formattingVisitor.FormattingMode = FormattingMode.Intrusive;
formattingVisitor.AddFormattingRegion(formattingRegion);
var changes = formattingVisitor.AnalyzeFormatting(stubData.Document, compilationUnit);
if (formatLastStatementOnly)
{
AstNode node = compilationUnit.GetAdjacentNodeAt <Statement> (stubData.OffsetToLocation(formatStartOffset + formatLength - 1));
if (node != null)
{
while (node.Role == Roles.EmbeddedStatement || node.Role == IfElseStatement.TrueRole || node.Role == IfElseStatement.FalseRole)
{
node = node.Parent;
}
// include indentation if node starts in new line
var formatNode = node.GetPrevNode();
if (formatNode.Role != Roles.NewLine)
{
formatNode = node;
}
var start = stubData.LocationToOffset(formatNode.StartLocation);
if (start > formatStartOffset)
{
var end = stubData.LocationToOffset(node.EndLocation);
formatStartOffset = start;
formatLength = end - start;
}
}
}
return(changes);
}
}
private static QueryFromClause GetPreviousQueryFromClause(AstNode node)
{
while (true)
{
node = node.GetPrevNode();
if (node == null)
{
return(null);
}
var qfc = node as QueryFromClause;
if (qfc != null)
{
return(qfc);
}
}
}
void PlaceOnNewLine(NewLinePlacement newLine, AstNode keywordNode)
{
if (keywordNode == null || newLine == NewLinePlacement.DoNotCare) {
return;
}
var prev = keywordNode.GetPrevNode (NoWhitespacePredicate);
if (prev is Comment || prev is PreProcessorDirective)
return;
int offset = document.GetOffset(keywordNode.StartLocation);
int whitespaceStart = SearchWhitespaceStart(offset);
string indentString = newLine == NewLinePlacement.NewLine ? options.EolMarker + curIndent.IndentString : " ";
AddChange(whitespaceStart, offset - whitespaceStart, indentString);
}
void FixOpenBrace(BraceStyle braceStyle, AstNode lbrace)
{
if (lbrace.IsNull)
return;
switch (braceStyle) {
case BraceStyle.DoNotChange:
return;
case BraceStyle.BannerStyle:
case BraceStyle.EndOfLine:
var prev = lbrace.GetPrevNode (NoWhitespacePredicate);
if (prev is PreProcessorDirective)
return;
int prevOffset = document.GetOffset(prev.EndLocation);
if (prev is Comment || prev is PreProcessorDirective) {
int next = document.GetOffset(lbrace.GetNextNode ().StartLocation);
AddChange(prevOffset, next - prevOffset, "");
while (prev is Comment || prev is PreProcessorDirective)
prev = prev.GetPrevNode();
prevOffset = document.GetOffset(prev.EndLocation);
AddChange(prevOffset, 0, " {");
} else {
int braceOffset2 = document.GetOffset(lbrace.StartLocation);
AddChange(prevOffset, braceOffset2 - prevOffset, " ");
}
break;
case BraceStyle.EndOfLineWithoutSpace:
prev = lbrace.GetPrevNode (NoWhitespacePredicate);
if (prev is PreProcessorDirective)
return;
prevOffset = document.GetOffset(prev.EndLocation);
int braceOffset = document.GetOffset(lbrace.StartLocation);
AddChange(prevOffset, braceOffset - prevOffset, "");
break;
case BraceStyle.NextLine:
prev = lbrace.GetPrevNode (NoWhitespacePredicate);
if (prev is PreProcessorDirective)
return;
prevOffset = document.GetOffset(prev.EndLocation);
braceOffset = document.GetOffset(lbrace.StartLocation);
AddChange(prevOffset, braceOffset - prevOffset, options.EolMarker + curIndent.IndentString);
break;
case BraceStyle.NextLineShifted:
prev = lbrace.GetPrevNode (NoWhitespacePredicate);
if (prev is PreProcessorDirective)
return;
prevOffset = document.GetOffset(prev.EndLocation);
braceOffset = document.GetOffset(lbrace.StartLocation);
curIndent.Push(IndentType.Block);
AddChange(prevOffset, braceOffset - prevOffset, options.EolMarker + curIndent.IndentString);
curIndent.Pop();
break;
case BraceStyle.NextLineShifted2:
prev = lbrace.GetPrevNode (NoWhitespacePredicate);
if (prev is PreProcessorDirective)
return;
prevOffset = document.GetOffset(prev.EndLocation);
braceOffset = document.GetOffset(lbrace.StartLocation);
curIndent.Push(IndentType.Block);
AddChange(prevOffset, braceOffset - prevOffset, options.EolMarker + curIndent.IndentString);
curIndent.Pop();
break;
}
}
void FixIndentationForceNewLine(AstNode node)
{
if (node.GetPrevNode () is NewLineNode) {
FixIndentation(node);
} else {
int offset = document.GetOffset(node.StartLocation);
AddChange(offset, 0, curIndent.IndentString);
}
}
void CorrectClosingBrace(AstNode rbrace)
{
int braceOffset = document.GetOffset(rbrace.StartLocation);
var prevNode = rbrace.GetPrevNode();
int prevNodeOffset = prevNode != null ? document.GetOffset(prevNode.EndLocation) : 0;
if (prevNode is NewLineNode) {
AddChange(prevNodeOffset, braceOffset - prevNodeOffset, curIndent.IndentString);
} else {
AddChange(prevNodeOffset, braceOffset - prevNodeOffset, options.EolMarker + curIndent.IndentString);
}
}
void EnforceBraceStyle(BraceStyle braceStyle, AstNode lbrace, AstNode rbrace)
{
if (lbrace.IsNull || rbrace.IsNull) {
return;
}
// LineSegment lbraceLineSegment = data.Document.GetLine (lbrace.StartLocation.Line);
int lbraceOffset = document.GetOffset(lbrace.StartLocation);
// LineSegment rbraceLineSegment = data.Document.GetLine (rbrace.StartLocation.Line);
int rbraceOffset = document.GetOffset(rbrace.StartLocation);
int whitespaceStart = SearchWhitespaceStart(lbraceOffset);
int whitespaceEnd = SearchWhitespaceLineStart(rbraceOffset);
string startIndent = "";
string endIndent = "";
switch (braceStyle) {
case BraceStyle.DoNotChange:
startIndent = endIndent = null;
break;
case BraceStyle.EndOfLineWithoutSpace:
startIndent = "";
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.BannerStyle:
var prevNode = lbrace.GetPrevNode();
if (prevNode is Comment) {
// delete old bracket
AddChange(whitespaceStart, lbraceOffset - whitespaceStart + 1, "");
while (prevNode is Comment) {
prevNode = prevNode.GetPrevNode();
}
whitespaceStart = document.GetOffset(prevNode.EndLocation);
lbraceOffset = whitespaceStart;
startIndent = " {";
} else {
startIndent = " ";
}
curIndent.Push(IndentType.Block);
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
curIndent.Pop();
break;
case BraceStyle.EndOfLine:
prevNode = lbrace.GetPrevNode();
if (prevNode is Comment) {
// delete old bracket
AddChange(whitespaceStart, lbraceOffset - whitespaceStart + 1, "");
while (prevNode is Comment) {
prevNode = prevNode.GetPrevNode();
}
whitespaceStart = document.GetOffset(prevNode.EndLocation);
lbraceOffset = whitespaceStart;
startIndent = " {";
} else {
startIndent = " ";
}
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.NextLine:
startIndent = this.options.EolMarker + curIndent.IndentString;
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
break;
case BraceStyle.NextLineShifted2:
case BraceStyle.NextLineShifted:
curIndent.Push(IndentType.Block);
startIndent = this.options.EolMarker + curIndent.IndentString;
endIndent = IsLineIsEmptyUpToEol(rbraceOffset) ? curIndent.IndentString : this.options.EolMarker + curIndent.IndentString;
curIndent.Pop ();
break;
}
if (lbraceOffset > 0 && startIndent != null) {
AddChange(whitespaceStart, lbraceOffset - whitespaceStart, startIndent);
}
if (rbraceOffset > 0 && endIndent != null) {
AddChange(whitespaceEnd, rbraceOffset - whitespaceEnd, endIndent);
}
}
void FixIndentationForceNewLine(AstNode node)
{
var directive = node as PreProcessorDirective;
if (node.GetPrevNode () is NewLineNode) {
if (directive != null && !policy.IndentPreprocessorDirectives) {
var startNode = node.GetPrevNode ();
var startOffset = document.GetOffset(startNode.EndLocation);
int endOffset = document.GetOffset(node.StartLocation);
AddChange(startOffset, endOffset - startOffset, "");
return;
} else {
FixIndentation(node);
}
} else {
// if no new line preceeds an #endif directive it's excluded
if (directive != null) {
if (directive.Type == PreProcessorDirectiveType.Endif)
return;
}
var startNode = node.GetPrevSibling(n => !(n is WhitespaceNode)) ?? node;
var startOffset = document.GetOffset(startNode.EndLocation);
int endOffset = document.GetOffset(node.StartLocation);
if (startOffset >= endOffset)
return;
if (directive != null && !policy.IndentPreprocessorDirectives) {
AddChange(startOffset, endOffset - startOffset, "");
return;
}
AddChange(startOffset, endOffset - startOffset, curIndent.IndentString);
}
}
void FixIndentationForceNewLine(AstNode node)
{
if (node.GetPrevNode () is NewLineNode) {
FixIndentation(node);
} else {
// if no new line preceeds an #endif directive it's excluded
var directive = node as PreProcessorDirective;
if (directive != null) {
if (directive.Type == PreProcessorDirectiveType.Endif)
return;
}
int offset = document.GetOffset(node.StartLocation);
AddChange(offset, 0, curIndent.IndentString);
}
}
static TextLocation GetPrevEnd(AstNode node)
{
var prev = node.GetPrevNode(n => !(n is NewLineNode));
return(prev != null ? prev.EndLocation : node.StartLocation);
}
