source: stable/HeuristicLab.ExtLibs/HeuristicLab.NRefactory/5.5.0/NRefactory.CSharp-5.5.0/Formatter/FormattingVisitor.cs @ 13400

// 
// FormattingVisitor.cs
//
// Author:
//       Mike Krüger <mkrueger@xamarin.com>
// 
// Copyright (c) 2010 Novell, Inc (http://www.novell.com)
// Copyright (c) 2013 Xamarin Inc. (http://xamarin.com)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
// 
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
using System;
using System.Text;
using System.Linq;
using ICSharpCode.NRefactory.Editor;
using ICSharpCode.NRefactory.TypeSystem;
using System.Threading;
using System.Collections.Generic;
using ICSharpCode.NRefactory.Utils;

namespace ICSharpCode.NRefactory.CSharp
{
  [Obsolete("This class was replaced by CSharpFormatter.")]
  public class AstFormattingVisitor {}

  partial class FormattingVisitor  
  {
    readonly CSharpFormatter formatter;
    readonly FormattingChanges changes;
    readonly IDocument document;
    readonly CancellationToken token;

    Indent curIndent;

    public bool HadErrors {
      get;
      set;
    }
    

    CSharpFormattingOptions policy {
      get {
        return formatter.Policy;
      }
    }

    TextEditorOptions options {
      get {
        return formatter.TextEditorOptions;
      }
    }

    FormattingChanges.TextReplaceAction AddChange(int offset, int removedChars, string insertedText)
    {
      return changes.AddChange(offset, removedChars, insertedText);
    }

    public FormattingVisitor(CSharpFormatter formatter, IDocument document, FormattingChanges changes, CancellationToken token)
    {
      if (formatter == null)
        throw new ArgumentNullException("formatter");
      if (document == null)
        throw new ArgumentNullException("document");
      if (changes == null)
        throw new ArgumentNullException("changes");
    
      this.formatter = formatter;
      this.changes = changes;
      this.document = document;
      this.token = token;

      curIndent = new Indent(formatter.TextEditorOptions);
    }
    
    void VisitChildrenToFormat (AstNode parent, Action<AstNode> callback)
    {
      AstNode next;
      for (var child = parent.FirstChild; child != null; child = next) {
        token.ThrowIfCancellationRequested();
        // Store next to allow the loop to continue
        // if the visitor removes/replaces child.
        next = child.GetNextSibling(NoWhitespacePredicate);
        
        if (formatter.FormattingRegions.Count > 0) {
          if (formatter.FormattingRegions.Any(r => r.IsInside(child.StartLocation) || r.IsInside(child.EndLocation))) {
            callback(child);
          } else {
            var childRegion = child.Region;
            if (formatter.FormattingRegions.Any(r => childRegion.IsInside(r.Begin) || childRegion.IsInside(r.End)))
                callback(child);
          }
          if (child.StartLocation > formatter.lastFormattingLocation)
            break;
        } else {
          callback(child);
        }
      }
    }
    
    protected override void VisitChildren (AstNode node)
    {
      VisitChildrenToFormat (node, n => n.AcceptVisitor (this));
    }

    #region NewLines

    void AdjustNewLineBlock(AstNode startNode, int targetMinimumNewLineCount)
    {
      var indentString = policy.EmptyLineFormatting == EmptyLineFormatting.Indent ? curIndent.IndentString : "";

      TextLocation newLineInsertPosition = startNode.EndLocation;
      var node = startNode.NextSibling;
      int currentNewLineCount = 0;
      // Check the existing newlines
      for (; currentNewLineCount < targetMinimumNewLineCount; node = node.NextSibling) {
        if (node is WhitespaceNode)
          continue;
        if (!(node is NewLineNode))
          break;
        newLineInsertPosition = node.EndLocation;
        currentNewLineCount++;
        if (policy.EmptyLineFormatting == EmptyLineFormatting.DoNotChange) {
          if (node.NextSibling == null)
            // end of file/block etc, nothing more to do but break before assigning null to node
            break;
          continue;
        }
        var isBlankLine = IsSpacing(document.GetLineByNumber(node.StartLocation.Line));
        if (!isBlankLine) {
          // remove EOL whitespace if appropriate
          if (policy.RemoveEndOfLineWhiteSpace) {
            var offset = document.GetOffset(node.StartLocation);
            var start = SearchWhitespaceStart(offset);
            if (start != offset)
              AddChange(start, offset - start, null);
          }
        } else {
          var actualIndent = GetIndentation(node.StartLocation.Line);
          if (actualIndent != indentString) {
            var start = document.GetOffset(new TextLocation(node.StartLocation.Line, 0));
            AddChange(start, actualIndent.Length, indentString);
          }
        }
        if (node.NextSibling == null)
          // end of file/block etc, nothing more to do but break before assigning null to node
          break;
      }
      if (currentNewLineCount < targetMinimumNewLineCount) {
        // We need to add more newlines
        var builder = new StringBuilder();
        for (; currentNewLineCount < targetMinimumNewLineCount; currentNewLineCount++) {
          if (currentNewLineCount > 0)
            // Don't indent the first line in the block since that is not an empty line.
            builder.Append(indentString);
          builder.Append(options.EolMarker);
        }
        var offset = document.GetOffset(newLineInsertPosition);
        if (offset >= 0)
          AddChange(offset, 0, builder.ToString());
      } else if (currentNewLineCount == targetMinimumNewLineCount && node is NewLineNode){
//        // Check to see if there are any newlines to remove
//        var endNode = node.GetNextSibling(n => !(n is NewLineNode || n is WhitespaceNode));
//        if (endNode != null) {
//          var startOffset = document.GetOffset(newLineInsertPosition);
//          var endOffset = document.GetOffset(new TextLocation(endNode.StartLocation.Line, 0));
//          EnsureText(startOffset, endOffset, null);
//        }
      }
    }

    public void EnsureMinimumNewLinesAfter(AstNode node, int blankLines)
    {
      if (node is PreProcessorDirective) {
        var directive = (PreProcessorDirective)node;
        if (directive.Type == PreProcessorDirectiveType.Pragma)
          return;
      }
      if (blankLines < 0)
        return;
      if (formatter.FormattingMode != FormattingMode.Intrusive)
        blankLines = Math.Min(1, blankLines);
      AdjustNewLineBlock(node, blankLines);
    }
    
    public void EnsureMinimumBlankLinesBefore(AstNode node, int blankLines)
    {
      if (formatter.FormattingMode != FormattingMode.Intrusive)
        return;
      var loc = node.StartLocation;
      int line = loc.Line;
      do {
        line--;
      } while (line > 0 && IsSpacing(document.GetLineByNumber(line)));
      if (line > 0 && !IsSpacing(document.GetLineByNumber(line)))
          line++;

      if (loc.Line - line >= blankLines)
        return;

      var sb = new StringBuilder ();
      for (int i = 0; i < blankLines; i++)
        sb.Append(options.EolMarker);
      int end = document.GetOffset(loc.Line, 1);
      if (loc.Line == line) {
        AddChange(end, 0, sb.ToString());
        return;
      }
      if (line + 1 > document.LineCount)
        return;
      int start = document.GetOffset(line + 1, 1);
      if (end - start <= 0 && sb.Length == 0)
        return;
      AddChange(start, end - start, sb.ToString());
    }

    #endregion

    bool IsSimpleAccessor(Accessor accessor)
    {
      if (accessor.IsNull || accessor.Body.IsNull || accessor.Body.FirstChild == null) {
        return true;
      }
      var firstStatement = accessor.Body.Statements.FirstOrDefault();
      if (firstStatement == null)
        return true;

      if (!(firstStatement is ReturnStatement || firstStatement is ExpressionStatement|| firstStatement is EmptyStatement || firstStatement is ThrowStatement))
        return false;

      if (firstStatement.GetNextSibling(s => s.Role == BlockStatement.StatementRole) != null)
        return false;

      return !(accessor.Body.Statements.FirstOrDefault() is BlockStatement);
    }
    
    static bool IsSpacing(char ch)
    {
      return ch == ' ' || ch == '\t';
    }
    
    bool IsSpacing(ISegment segment)
    {
      int endOffset = segment.EndOffset;
      for (int i = segment.Offset; i < endOffset; i++) {
        if (!IsSpacing(document.GetCharAt(i))) {
          return false;
        }
      }
      return true;
    }
    
    int SearchLastNonWsChar(int startOffset, int endOffset)
    {
      startOffset = Math.Max(0, startOffset);
      endOffset = Math.Max(startOffset, endOffset);
      if (startOffset >= endOffset) {
        return startOffset;
      }
      int result = -1;
      bool inComment = false;
      
      for (int i = startOffset; i < endOffset && i < document.TextLength; i++) {
        char ch = document.GetCharAt(i);
        if (IsSpacing(ch)) {
          continue;
        }
        if (ch == '/' && i + 1 < document.TextLength && document.GetCharAt(i + 1) == '/') {
          return result;
        }
        if (ch == '/' && i + 1 < document.TextLength && document.GetCharAt(i + 1) == '*') {
          inComment = true;
          i++;
          continue;
        }
        if (inComment && ch == '*' && i + 1 < document.TextLength && document.GetCharAt(i + 1) == '/') {
          inComment = false;
          i++;
          continue;
        }
        if (!inComment) {
          result = i;
        }
      }
      return result;
    }
    
    void ForceSpace(int startOffset, int endOffset, bool forceSpace)
    {
      int lastNonWs = SearchLastNonWsChar(startOffset, endOffset);
      if (lastNonWs < 0)
        return;

      var spaceCount = Math.Max(0, endOffset - lastNonWs - 1);
      if (forceSpace) {
        if (spaceCount != 1) {
          // Here we could technically remove spaceCount - 1 chars instead
          // and skip replacing that with new space, but we want to trigger the
          // overlap detection if this space is changed again for some reason
          AddChange(lastNonWs + 1, spaceCount, " ");
        }
      } else if (spaceCount > 0 && !forceSpace) {
        AddChange(lastNonWs + 1, spaceCount, "");
      }
    }
    
    void ForceSpacesAfter(AstNode n, bool forceSpaces)
    {
      if (n == null) {
        return;
      }
      TextLocation location = n.EndLocation;
      int offset = document.GetOffset(location);
      if (location.Column > document.GetLineByNumber(location.Line).Length) {
        return;
      }
      int i = offset;
      while (i < document.TextLength && IsSpacing (document.GetCharAt (i))) {
        i++;
      }
      ForceSpace(offset - 1, i, forceSpaces);
    }

    int ForceSpacesBefore(AstNode n, bool forceSpaces)
    {
      if (n == null || n.IsNull) {
        return 0;
      }
      TextLocation location = n.StartLocation;
      // respect manual line breaks.
      if (location.Column <= 1 || GetIndentation(location.Line).Length == location.Column - 1) {
        return 0;
      }
      
      int offset = document.GetOffset(location);
      int i = offset - 1;
      while (i >= 0 && IsSpacing (document.GetCharAt (i))) {
        i--;
      }
      ForceSpace(i, offset, forceSpaces);
      return i;
    }
    
    int ForceSpacesBeforeRemoveNewLines(AstNode n, bool forceSpace = true)
    {
      if (n == null || n.IsNull) {
        return 0;
      }
      int offset = document.GetOffset(n.StartLocation);
      int i = offset - 1;
      while (i >= 0) {
        char ch = document.GetCharAt(i);
        if (!IsSpacing(ch) && ch != '\r' && ch != '\n')
          break;
        i--;
      }
      var length = Math.Max(0, (offset - 1) - i);
      AddChange(i + 1, length, forceSpace ? " " : "");
      return i;
    }

    internal static bool NoWhitespacePredicate(AstNode arg)
    {
      return !(arg is NewLineNode || arg is WhitespaceNode);
    }

    static bool IsMember(AstNode nextSibling)
    {
      return nextSibling != null && nextSibling.NodeType == NodeType.Member;
    }

    static bool ShouldBreakLine(NewLinePlacement placement, CSharpTokenNode token)
    {
      if (placement == NewLinePlacement.NewLine)
        return true;
      if (placement == NewLinePlacement.SameLine)
        return false;
      if (token.IsNull)
        return false;
      var prevMeaningfulNode = token.GetPrevNode (n =>n.Role !=Roles.NewLine && n.Role != Roles.Whitespace && n.Role !=Roles.Comment);
      return prevMeaningfulNode.EndLocation.Line != token.StartLocation.Line;
    }

    void ForceSpaceBefore(AstNode node, bool forceSpace)
    {
      var offset = document.GetOffset(node.StartLocation);
      int end = offset;
      // ForceSpace inserts a space one char after start in the case of a missing space
      // Therefore, make sure that start < offset by starting at offset - 1
      int start = SearchWhitespaceStart(offset - 1);
      ForceSpace(start, end, forceSpace);
    }

    public void FixSemicolon(CSharpTokenNode semicolon)
    {
      if (semicolon.IsNull)
        return;
      int endOffset = document.GetOffset(semicolon.StartLocation);
      int offset = endOffset;
      while (offset - 1 > 0 && char.IsWhiteSpace (document.GetCharAt (offset - 1))) {
        offset--;
      }
      if (policy.SpaceBeforeSemicolon) {
        AddChange(offset, endOffset - offset, " ");
      } else {
        if (offset < endOffset)
          AddChange(offset, endOffset - offset, null);
      }
    }
    
    void PlaceOnNewLine(NewLinePlacement newLine, AstNode keywordNode)
    {
      if (keywordNode == null || keywordNode.StartLocation.IsEmpty)
        return;
      
      var prev = keywordNode.GetPrevNode (NoWhitespacePredicate);
      if (prev is Comment || prev is PreProcessorDirective)
        return;

      if (newLine == NewLinePlacement.DoNotCare)
        newLine = prev.EndLocation.Line == keywordNode.StartLocation.Line ? NewLinePlacement.SameLine : NewLinePlacement.NewLine;

      int offset = document.GetOffset(keywordNode.StartLocation);
      
      int whitespaceStart = SearchWhitespaceStart(offset);
      string indentString = newLine == NewLinePlacement.NewLine ? options.EolMarker + curIndent.IndentString : " ";
      AddChange(whitespaceStart, offset - whitespaceStart, indentString);
    }
    
    string nextStatementIndent;
    
    void FixStatementIndentation(TextLocation location)
    {
      if (location.Line < 1 || location.Column < 1) {
        Console.WriteLine("invalid location!");
        return;
      }
      int offset = document.GetOffset(location);
      if (offset <= 0) {
        Console.WriteLine("possible wrong offset");
        Console.WriteLine(Environment.StackTrace);
        return;
      }
      bool isEmpty = IsLineIsEmptyUpToEol(offset);
      int lineStart = SearchWhitespaceLineStart(offset);
      string indentString = nextStatementIndent ?? (isEmpty ? "" : options.EolMarker) + curIndent.IndentString;
      nextStatementIndent = null;
      EnsureText(lineStart, offset, indentString);
    }

    void FixIndentation (AstNode node)
    {
      FixIndentation(node.StartLocation, 0);
    }
    
    void FixIndentation(TextLocation location, int relOffset)
    {
      if (location.Line < 1 || location.Line > document.LineCount) {
        Console.WriteLine("Invalid location " + location);
        Console.WriteLine(Environment.StackTrace);
        return;
      }
      
      string lineIndent = GetIndentation(location.Line);
      string indentString = curIndent.IndentString;
      if (indentString != lineIndent && location.Column - 1 + relOffset == lineIndent.Length) {
        AddChange(document.GetOffset(location.Line, 1), lineIndent.Length, indentString);
      }
    }
    
    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);
      }
    }

    string GetIndentation(int lineNumber)
    {
      var line = document.GetLineByNumber(lineNumber);
      var b = new StringBuilder ();
      int endOffset = line.EndOffset;
      for (int i = line.Offset; i < endOffset; i++) {
        char c = document.GetCharAt(i);
        if (!IsSpacing(c)) {
          break;
        }
        b.Append(c);
      }
      return b.ToString();
    }

    void EnsureText(int start, int end, string replacementText)
    {
      var length = end - start;
      if (length == 0 && string.IsNullOrEmpty(replacementText))
        return;
      if (replacementText == null || replacementText.Length != length) {
        AddChange(start, length, replacementText);
        return;
      }
      for (int i = 0; i < length; i++) {
        if (document.GetCharAt(start + i) != replacementText[i]) {
          AddChange(start, length, replacementText);
          break;
        }
      }
    }
    
    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);
            EnsureText(prevOffset, next, "");
            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);
            EnsureText(prevOffset, braceOffset2, " ");
          }
          break;
        case BraceStyle.EndOfLineWithoutSpace:
          prev = lbrace.GetPrevNode (NoWhitespacePredicate);
          if (prev is PreProcessorDirective)
            return;
          prevOffset = document.GetOffset(prev.EndLocation);
          int braceOffset = document.GetOffset(lbrace.StartLocation);
          EnsureText(prevOffset, braceOffset, "");
          break;

        case BraceStyle.NextLine:
          prev = lbrace.GetPrevNode (NoWhitespacePredicate);
          if (prev is PreProcessorDirective)
            return;
          prevOffset = document.GetOffset(prev.EndLocation);
          braceOffset = document.GetOffset(lbrace.StartLocation);
          EnsureText(prevOffset, braceOffset, 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);
          EnsureText(prevOffset, braceOffset, 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);
          EnsureText(prevOffset, braceOffset, options.EolMarker + curIndent.IndentString);
          curIndent.Pop();
          break;
      }
    }

    void CorrectClosingBrace (AstNode rbrace)
    {
      if (rbrace.IsNull)
        return;
      int braceOffset = document.GetOffset(rbrace.StartLocation);
      var prevNode = rbrace.GetPrevNode();
      int prevNodeOffset = prevNode != null ? document.GetOffset(prevNode.EndLocation) : 0;
      if (prevNode is NewLineNode) {
        EnsureText(prevNodeOffset, braceOffset, curIndent.IndentString);
      } else {
        EnsureText(prevNodeOffset, braceOffset, options.EolMarker + curIndent.IndentString);
      }
    }

    void FixClosingBrace(BraceStyle braceStyle, AstNode rbrace)
    {
      if (rbrace.IsNull)
        return;
      switch (braceStyle) {
        case BraceStyle.DoNotChange:
          return;

        case BraceStyle.NextLineShifted:
        case BraceStyle.BannerStyle:
          curIndent.Push(IndentType.Block);
          CorrectClosingBrace (rbrace);
          curIndent.Pop ();
          break;
        case BraceStyle.EndOfLineWithoutSpace:
        case BraceStyle.EndOfLine:
        case BraceStyle.NextLine:
          CorrectClosingBrace (rbrace);
          break;

        case BraceStyle.NextLineShifted2:
          curIndent.Push(IndentType.Block);
          CorrectClosingBrace (rbrace);
          curIndent.Pop ();
          break;
      }

    }

  }
}