private void MakeFormat(FormattingRange range, IEnumerable <string> space) { PsiFormatterHelper.ReplaceSpaces(range.First, range.Last, space); // TODO: Move antiglueing logic into CalcSpaces() ITokenNode nextToken; ITokenNode prevToken = range.First.FindLastTokenIn(); if (prevToken != null) { nextToken = prevToken.GetNextToken(); } else { nextToken = range.First.NextSibling.FindFirstTokenIn(); if (nextToken != null) { prevToken = nextToken.GetPrevToken(); } } if (prevToken != null && nextToken != null) { ITokenNode separator = Context.CodeFormatter.GetMinimalSeparator(prevToken, nextToken); if (separator != null) { LowLevelModificationUtil.AddChildAfter(range.First, separator); } } }
/// <summary> /// The code must not contain multiple whitespace in a row. /// </summary> /// <param name="node"> /// The node. /// </param> public static void CodeMustNotContainMultipleWhitespaceInARow(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode currentToken = currentNode as ITokenNode; ITokenNode previousToken = currentToken.GetPrevToken(); if (previousToken != null) { if (currentToken.GetTokenType() == CSharpTokenType.WHITE_SPACE && previousToken.GetTokenType() == CSharpTokenType.WHITE_SPACE) { using (WriteLockCookie.Create(true)) { LowLevelModificationUtil.DeleteChild(currentToken); } } } } if (currentNode.FirstChild != null) { CodeMustNotContainMultipleWhitespaceInARow(currentNode.FirstChild); } } }
/// <summary> /// Negative and positive signs must be spaced correctly. /// </summary> /// <param name="node"> /// The node to use. /// </param> /// <param name="tokenToCheck"> /// The token to check. /// </param> public static void NegativeAndPositiveSignsMustBeSpacedCorrectly(ITreeNode node, TokenNodeType tokenToCheck) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode tokenNode = currentNode as ITokenNode; if (tokenNode.GetTokenType() == tokenToCheck) { if (tokenNode.Parent is IOperatorExpression && !(tokenNode.Parent is IAdditiveExpression)) { ITokenNode nextToken = tokenNode.GetNextToken(); if (nextToken.IsWhitespace()) { using (WriteLockCookie.Create(true)) { // remove the whitespace or new line LowLevelModificationUtil.DeleteChild(nextToken); } } } } } if (currentNode.FirstChild != null) { NegativeAndPositiveSignsMustBeSpacedCorrectly(currentNode.FirstChild, tokenToCheck); } } }
public override void Regenerate(IndependentInjectedNodeContext nodeContext) { var htmlAttributeValue = nodeContext.OriginalContextNode as IHtmlAttributeValue; if (htmlAttributeValue == null) { Logger.Fail("Original node is not IHtmlAttributeValue"); return; } if (htmlAttributeValue.LeadingQuote == null) { Logger.Fail("No leading quote"); return; } var buffer = nodeContext.GeneratedNode.GetTextAsBuffer(); var token = htmlAttributeValue.LeadingQuote.TokenTypes.ATTRIBUTE_VALUE.Create(buffer, TreeOffset.Zero, new TreeOffset(buffer.Length)) as IHtmlToken; var list = htmlAttributeValue.ValueElements.ToArray(); if (list.Any()) { LowLevelModificationUtil.DeleteChildRange(list.First(), list.Last()); } LowLevelModificationUtil.AddChildAfter(htmlAttributeValue.LeadingQuote, token); }
public void MakeIndent(ITreeNode indentNode, string indent) { var lastSpace = AsWhitespaceNode(indentNode.PrevSibling); if (lastSpace != null && lastSpace.GetTokenType() != NewLineType) { var firstSpace = LeftWhitespaces(lastSpace).TakeWhile(ws => ws.GetTokenType() != NewLineType).LastOrDefault() ?? lastSpace; if (firstSpace != lastSpace || lastSpace.GetText() != indent) { if (indent.IsEmpty()) { LowLevelModificationUtil.DeleteChildRange(firstSpace, lastSpace); } else { LowLevelModificationUtil.ReplaceChildRange(firstSpace, lastSpace, CreateSpace(indent)); } } } else if (!indent.IsEmpty()) { LowLevelModificationUtil.AddChildBefore(indentNode, CreateSpace(indent)); } }
/// <summary> /// Do not place regions within elements. /// </summary> /// <param name="node"> /// The node to process. /// </param> private void DoNotPlaceRegionsWithinElements(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode tokenNode = currentNode as ITokenNode; if (tokenNode.GetTokenType() == CSharpTokenType.PP_START_REGION) { IStartRegion startRegionNode = tokenNode.GetContainingNode <IStartRegion>(true); if (startRegionNode != null) { if (startRegionNode.Parent is IBlock) { // we're in a block so remove the end and start region IEndRegion endRegionNode = startRegionNode.EndRegion; using (WriteLockCookie.Create(true)) { LowLevelModificationUtil.DeleteChild(endRegionNode); LowLevelModificationUtil.DeleteChild(startRegionNode); } } } } } if (currentNode.FirstChild != null) { this.DoNotPlaceRegionsWithinElements(currentNode.FirstChild); } } }
private void ChangeDocumentation(string text) { text = text.Trim('\r', '\n'); if (!string.IsNullOrEmpty(text)) { var newNode = GetElementFactory().CreateDocCommentBlock(text); if (IsCreated) { LowLevelModificationUtil.ReplaceChildRange(Node, Node, newNode); } else { LowLevelModificationUtil.AddChildBefore(AnalyzeUnit.Node.FirstChild, newNode); } newNode.FormatNode(); Node = newNode; } else if (Node != null) { LowLevelModificationUtil.DeleteChild(Node); Node = null; } Update(); }
/// <summary> /// Code must not contain empty statements. /// </summary> /// <param name="node"> /// The node to process. /// </param> private void CodeMustNotContainEmptyStatements(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode tokenNode = currentNode as ITokenNode; if (tokenNode.GetTokenType() == CSharpTokenType.SEMICOLON && !(tokenNode.Parent is IForStatement)) { ITokenNode nextNonWhitespaceToken = Utils.GetFirstNonWhitespaceTokenToRight(tokenNode); while (nextNonWhitespaceToken.GetTokenType() == CSharpTokenType.SEMICOLON) { using (WriteLockCookie.Create(true)) { if (nextNonWhitespaceToken.GetNextToken().GetTokenType() == CSharpTokenType.WHITE_SPACE) { LowLevelModificationUtil.DeleteChild(nextNonWhitespaceToken.GetNextToken()); } // remove the spare semi colon LowLevelModificationUtil.DeleteChild(nextNonWhitespaceToken); nextNonWhitespaceToken = Utils.GetFirstNonWhitespaceTokenToRight(tokenNode); } } } } if (currentNode.FirstChild != null) { this.CodeMustNotContainEmptyStatements(currentNode.FirstChild); } } }
IReferenceExpression IReferenceExpression.SetName(string name) { var newToken = new FSharpIdentifierToken(name); LowLevelModificationUtil.ReplaceChildRange(this, this, newToken); return(newToken); }
public static void MakeIndent(this ITreeNode indentNode, string indent) { var lastSpace = indentNode.PrevSibling as IWhitespaceNode; if (lastSpace != null && lastSpace.GetTokenType() != PsiTokenType.NEW_LINE) { ITreeNode firstSpace = lastSpace.LeftWhitespaces().TakeWhile(ws => ws != PsiTokenType.NEW_LINE).LastOrDefault() ?? lastSpace; while (firstSpace.GetTokenType() != PsiTokenType.NEW_LINE) { firstSpace = firstSpace.GetNextToken(); } firstSpace = firstSpace.GetNextToken(); if (firstSpace != lastSpace || lastSpace.GetText() != indent) { if (indent.IsEmpty()) { LowLevelModificationUtil.DeleteChildRange(firstSpace, lastSpace); } else { LowLevelModificationUtil.ReplaceChildRange(firstSpace, lastSpace, CreateSpace(indent)); } } } else if (!indent.IsEmpty()) { LowLevelModificationUtil.AddChildBefore(indentNode, CreateSpace(indent)); } }
/// <summary> /// Preprocessor keywords must not be preceded by space. /// </summary> /// <param name="node"> /// The node to use. /// </param> public static void PreprocessorKeywordsMustNotBePrecededBySpace(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is IPreprocessorDirective) { IPreprocessorDirective preprocessorDirectiveNode = currentNode as IPreprocessorDirective; TreeOffset directiveTokenNodeOffset = preprocessorDirectiveNode.Directive.GetTreeStartOffset(); TreeOffset numberSignTokenNodeOffset = preprocessorDirectiveNode.NumberSign.GetTreeStartOffset(); if (directiveTokenNodeOffset - 1 != numberSignTokenNodeOffset) { // There is a gap between them ITokenNode tokenNode = preprocessorDirectiveNode.NumberSign; ITokenNode nextToken = tokenNode.GetNextToken(); using (WriteLockCookie.Create(true)) { // remove the whitespace or new line LowLevelModificationUtil.DeleteChild(nextToken); } } } if (currentNode.FirstChild != null) { PreprocessorKeywordsMustNotBePrecededBySpace(currentNode.FirstChild); } } }
protected virtual void DoPutNewIndents([NotNull] IFormalParameterList parameters) { LowLevelModificationUtil.AddChildBefore(parameters, CreateLineBreakToken()); foreach (var paramDecl in parameters.ParameterDeclarationsEnumerable.Skip(1)) { LowLevelModificationUtil.AddChildBefore(paramDecl, CreateLineBreakToken()); } }
IReferenceExpression IReferenceExpression.SetName(string name) { if (IdentifierToken is var id && id != null) { LowLevelModificationUtil.ReplaceChildRange(id, id, new FSharpIdentifierToken(name)); } return(this); }
/// <summary> /// Inserts a newline in front of the Node provided. /// </summary> /// <param name="currentNode"> /// The node to insert in front of. /// </param> /// <returns> /// The inserted ITreeNode. /// </returns> public static ITreeNode InsertNewLineBefore(this ITreeNode currentNode) { LeafElementBase leafElement = GetLeafElement(); using (WriteLockCookie.Create(true)) { LowLevelModificationUtil.AddChildBefore(currentNode, new[] { leafElement }); } return(leafElement); }
/// <summary> /// Commas must be spaced correctly. /// </summary> /// <param name="node"> /// The node to use. /// </param> public void EqualsMustBeSpacedCorrectly(ITreeNode node) { List <TokenNodeType> tokensThatCanBeLeftSideOfEquals = new List <TokenNodeType> { CSharpTokenType.WHITE_SPACE, CSharpTokenType.NE, CSharpTokenType.LT, CSharpTokenType.GT }; const string WhiteSpace = " "; for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ITokenNode tokenNode = currentNode as ITokenNode; if (tokenNode.GetTokenType() == CSharpTokenType.EQ) { ITokenNode nextToken = tokenNode.GetNextToken(); ITokenNode previousToken = tokenNode.GetPrevToken(); if (!nextToken.IsWhitespace()) { using (WriteLockCookie.Create(true)) { // insert a space LeafElementBase leafElement = TreeElementFactory.CreateLeafElement( CSharpTokenType.WHITE_SPACE, new JetBrains.Text.StringBuffer(WhiteSpace), 0, WhiteSpace.Length); LowLevelModificationUtil.AddChildBefore(nextToken, new ITreeNode[] { leafElement }); } } if (!tokensThatCanBeLeftSideOfEquals.Contains(previousToken.GetTokenType())) { using (WriteLockCookie.Create(true)) { // insert a space LeafElementBase leafElement = TreeElementFactory.CreateLeafElement( CSharpTokenType.WHITE_SPACE, new JetBrains.Text.StringBuffer(WhiteSpace), 0, WhiteSpace.Length); LowLevelModificationUtil.AddChildBefore(tokenNode, new ITreeNode[] { leafElement }); } } } } if (currentNode.FirstChild != null) { this.EqualsMustBeSpacedCorrectly(currentNode.FirstChild); } } }
public static void ReplaceIdentifier([CanBeNull] this IFSharpIdentifier fsIdentifier, string name) { // todo: replace the composite identifier node with a single token where possible if (!(fsIdentifier?.FirstChild is FSharpIdentifierToken token)) { return; } name = Lexhelp.Keywords.QuoteIdentifierIfNeeded(name); using (WriteLockCookie.Create(fsIdentifier.IsPhysical())) LowLevelModificationUtil.ReplaceChildRange(token, token, new FSharpIdentifierToken(name)); }
public override CSharpPostfixExpressionContext FixExpression(CSharpPostfixExpressionContext context) { var psiServices = Reference.GetPsiServices(); var expressionRange = ExecutionContext.GetDocumentRange(context.Expression); var referenceRange = ExecutionContext.GetDocumentRange(Reference); var textWithReference = expressionRange.SetEndTo(referenceRange.TextRange.EndOffset).GetText(); var indexOfReferenceDot = textWithReference.LastIndexOf('.'); if (indexOfReferenceDot <= 0) { return(context); } var realReferenceRange = referenceRange.SetStartTo(expressionRange.TextRange.StartOffset + indexOfReferenceDot); var transactionManager = psiServices.Transactions.DocumentTransactionManager; var document = expressionRange.Document; // todo: make sure this is not in undo stack! using (transactionManager.CreateTransactionCookie(DefaultAction.Commit, FixCommandName)) { document.ReplaceText(realReferenceRange.TextRange, ")"); document.InsertText(expressionRange.TextRange.StartOffset, "unchecked("); } //using (psiServices.Solution.CreateTransactionCookie(DefaultAction.Commit, FixCommandName, NullProgressIndicator.Instance)) //{ // //} psiServices.Files.CommitAllDocuments(); var uncheckedExpression = TextControlToPsi.GetElement <IUncheckedExpression>(psiServices.Solution, document, expressionRange.TextRange.StartOffset + 1); if (uncheckedExpression == null) { return(context); } var operand = uncheckedExpression.Operand; psiServices.Transactions.Execute(FixCommandName, () => { LowLevelModificationUtil.DeleteChild(operand); LowLevelModificationUtil.ReplaceChildRange(uncheckedExpression, uncheckedExpression, operand); }); Assertion.Assert(operand.IsPhysical(), "operand.IsPhysical()"); return(new CSharpPostfixExpressionContext(this, operand)); }
public static void ReplaceIdentifier([CanBeNull] this IFSharpIdentifier fsIdentifier, string name) { var token = fsIdentifier?.IdentifierToken; if (token == null) { return; } name = NamingManager.GetNamingLanguageService(fsIdentifier.Language).MangleNameIfNecessary(name); using (WriteLockCookie.Create(fsIdentifier.IsPhysical())) LowLevelModificationUtil.ReplaceChildRange(token, token, new FSharpIdentifierToken(name)); }
public static void ReplaceChild(ITreeNode parent, ITreeNode nameNode, string name) { if (name.IsEmpty()) { throw new ArgumentException("name shouldn't be empty", "name"); } using (WriteLockCookie.Create(parent.IsPhysical())) { IRuleName ruleName = PsiElementFactory.GetInstance(parent.GetPsiModule()).CreateIdentifierExpression(name); LowLevelModificationUtil.ReplaceChildRange(nameNode, nameNode, ruleName.FirstChild); } }
public void ProcessBeforeInterior(ITreeNode element) { var header = element as IXmlTagHeader; if (header == null) { return; } // note: using LINQ's .OrderBy() because of stable sorting behavior var sortedAttributes = header.Attributes.OrderBy(x => x, _orderComparer).ToList(); if (sortedAttributes.SequenceEqual(header.AttributesEnumerable)) { return; } using (WriteLockCookie.Create()) { var xamlFactory = XamlElementFactory.GetInstance(header); var replacementMap = new Dictionary <IXmlAttribute, IXmlAttribute>(); // I'm using LowLevelModificationUtil to physically modify AST at low-level, // without cloning, invoking reference binds and formatting // (like ModificationUtil.*/.RemoveAttribute()/.AddAttributeBefore() methods do). var attributes = header.Attributes; for (var index = 0; index < attributes.Count; index++) { var attribute = attributes[index]; var sortedAttribute = sortedAttributes[index]; if (attribute == sortedAttribute) { continue; } // replace attribute to be reordered with fake attribute var fakeAttribute = xamlFactory.CreateRootAttribute("fake"); LowLevelModificationUtil.ReplaceChildRange(attribute, attribute, fakeAttribute); replacementMap.Add(fakeAttribute, sortedAttribute); } // now all attributes in 'replacementMap' are detached from AST and replaces with fake ones // let's now replace fakes with attributes in order: foreach (var attribute in replacementMap) { var fakeAttribute = attribute.Key; LowLevelModificationUtil.ReplaceChildRange(fakeAttribute, fakeAttribute, attribute.Value); } } }
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress) { var sceneName = myWarning.SceneName; Assertion.Assert(sceneName != null, "sceneName != null"); var unityModule = GetUnityModule(solution); Assertion.Assert(unityModule != null, "unityModule != null"); var buildSettings = GetEditorBuildSettings(unityModule); var scenes = GetSceneCollection(buildSettings.GetDominantPsiFile <UnityYamlLanguage>() as IYamlFile) as IBlockSequenceNode; Assertion.Assert(scenes != null, "scene != null"); foreach (var entry in scenes.Entries) { var scene = entry.Value; var sceneRecord = scene as IBlockMappingNode; if (sceneRecord == null) { continue; } var path = GetUnityScenePathRepresentation( (sceneRecord.Entries[1].Content.Value as IPlainScalarNode).NotNull("PlainScalarNode:1").Text.GetText()); var simple = path.Split('/').Last(); var isEnabledPlaneScalarNode = (sceneRecord.Entries[0].Content.Value as IPlainScalarNode).NotNull("PlainScalarNode:0"); var isEnabled = isEnabledPlaneScalarNode.Text.GetText().Equals("1"); if (!isEnabled && (path.Equals(sceneName) || simple.Equals(sceneName))) { using (WriteLockCookie.Create(myWarning.Argument.IsPhysical())) { var text = YamlTokenType.NS_PLAIN_ONE_LINE_IN.Create("1"); if (isEnabledPlaneScalarNode.Text != null) { LowLevelModificationUtil.ReplaceChildRange(isEnabledPlaneScalarNode.Text, isEnabledPlaneScalarNode.Text, text); } else { LowLevelModificationUtil.AddChild(isEnabledPlaneScalarNode.Text, text); } } } solution.GetComponent <IDaemon>().Invalidate(); solution.GetComponent <UnityRefresher>().Refresh(RefreshType.Normal); } return(null); }
public void AdjustLeadingAndTrailingWhitespaces(CppCodeFormatter cppCodeFormatter, CppFile cppFile) { var cgProgram = (cppFile.Parent as IInjectedFileHolder)?.OriginalNode.PrevSibling; var s = ShaderLabCppFormatterExtension.GetIndentInCgProgram(cgProgram); cppCodeFormatter.RemoveLeadingSpacesInFile(cppFile); cppCodeFormatter.RemoveTrailingSpaces(cppFile); var lineEnding = cppFile.DetectLineEnding(cppFile.GetPsiServices()); LowLevelModificationUtil.AddChildBefore(cppFile.firstChild, cppCodeFormatter.CreateNewLine(lineEnding), cppCodeFormatter.CreateSpace(s, null)); LowLevelModificationUtil.AddChildAfter(cppFile.lastChild, cppCodeFormatter.CreateNewLine(lineEnding), cppCodeFormatter.CreateSpace(s, null)); }
/// <summary> /// Remove empty comments. /// </summary> /// <param name="node"> /// The node to process. /// </param> public static void RemoveEmptyComments(ITreeNode node) { // we don't remove empty lines from Element Doc Comments in here // the DeclarationHeader types take care of that. for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ITokenNode) { ICommentNode commentNode = currentNode as ICommentNode; if (commentNode != null && !(commentNode is IDocCommentNode)) { if (commentNode.CommentText.Trim() == string.Empty) { ITokenNode leftToken = Utils.GetFirstNewLineTokenToLeft((ITokenNode)currentNode); ITokenNode rightToken = Utils.GetFirstNewLineTokenToRight((ITokenNode)currentNode); if (leftToken == null) { leftToken = (ITokenNode)currentNode; } else { leftToken = leftToken.GetNextToken(); } if (rightToken == null) { rightToken = (ITokenNode)currentNode; } else { currentNode = rightToken.GetNextToken(); } using (WriteLockCookie.Create(true)) { LowLevelModificationUtil.DeleteChildRange(leftToken, rightToken); } } } } if (currentNode != null && currentNode.FirstChild != null) { RemoveEmptyComments(currentNode.FirstChild); } } }
/// <summary> /// Remove parenthesis from node. /// </summary> /// <param name="node"> /// The node. /// </param> public static void RemoveParenthesisFromNode(ITreeNode node) { IParenthesizedExpression parenthesizedExpressionNode = node as IParenthesizedExpression; if (parenthesizedExpressionNode != null) { using (WriteLockCookie.Create(true)) { ICSharpExpression innerExpression = parenthesizedExpressionNode.Expression; if (innerExpression != null && node.Parent != null) { NodeType innerExpressionNodeType = (innerExpression as TreeElement).NodeType; if (innerExpressionNodeType != ElementType.ADDITIVE_EXPRESSION && innerExpressionNodeType != ElementType.MULTIPLICATIVE_EXPRESSION && innerExpressionNodeType != ElementType.SHIFT_EXPRESSION && innerExpressionNodeType != ElementType.AS_EXPRESSION && innerExpressionNodeType != ElementType.ASSIGNMENT_EXPRESSION && innerExpressionNodeType != ElementType.CAST_EXPRESSION && innerExpressionNodeType != ElementType.CONDITIONAL_AND_EXPRESSION && innerExpressionNodeType != ElementType.CONDITIONAL_OR_EXPRESSION && innerExpressionNodeType != ElementType.CONDITIONAL_TERNARY_EXPRESSION && innerExpressionNodeType != ElementType.POSTFIX_OPERATOR_EXPRESSION && innerExpressionNodeType != ElementType.PREFIX_OPERATOR_EXPRESSION && innerExpressionNodeType != ElementType.IS_EXPRESSION && innerExpressionNodeType != ElementType.LAMBDA_EXPRESSION && innerExpressionNodeType != ElementType.BITWISE_AND_EXPRESSION && innerExpressionNodeType != ElementType.BITWISE_INCLUSIVE_OR_EXPRESSION && innerExpressionNodeType != ElementType.BITWISE_EXCLUSIVE_OR_EXPRESSION && innerExpressionNodeType != ElementType.OBJECT_CREATION_EXPRESSION && innerExpressionNodeType != ElementType.ARRAY_CREATION_EXPRESSION && innerExpressionNodeType != ElementType.NULL_COALESCING_EXPRESSION && innerExpressionNodeType != ElementType.QUERY_EXPRESSION && innerExpressionNodeType != ElementType.RELATIONAL_EXPRESSION && innerExpressionNodeType != ElementType.UNARY_OPERATOR_EXPRESSION && innerExpressionNodeType != ElementType.EQUALITY_EXPRESSION && innerExpressionNodeType != ElementType.AWAIT_EXPRESSION) { LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression }); return; } if ((!(node.Parent is IExpression)) || node.Parent is IVariableDeclaration) { LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression }); return; } IAssignmentExpression parent = node.Parent as IAssignmentExpression; if (parent != null && parent.Source == node) { LowLevelModificationUtil.ReplaceChildRange(node, node, new ITreeNode[] { innerExpression }); return; } } } } }
public override IReference BindTo(IDeclaredElement element) { using (WriteLockCookie.Create(myOwner.IsPhysical())) { var text = YamlTokenType.NS_PLAIN_ONE_LINE_IN.Create(element.ShortName); if (myOwner.Text != null) { LowLevelModificationUtil.ReplaceChildRange(myOwner.Text, myOwner.Text, text); } else { LowLevelModificationUtil.AddChild(myOwner.Text, text); } } return(this); }
public override PrefixExpressionContext FixExpression(PrefixExpressionContext context) { var expression = context.Expression; if (expression.Contains(Reference)) // x is T.bar => x is T { expression.GetPsiServices().DoTransaction(FixCommandName, () => { var referenceName = (IReferenceName)Reference; var qualifier = referenceName.Qualifier; LowLevelModificationUtil.DeleteChild(qualifier); // remove first return(referenceName.ReplaceBy(qualifier)); }); } return(context); }
/// <summary> /// Delete child range. /// </summary> /// <param name="first"> /// The first token to delete. /// </param> /// <param name="last"> /// The last token to delete. /// </param> private static void DeleteChildRange(ITokenNode first, ITokenNode last) { using (WriteLockCookie.Create(true)) { List <ITokenNode> a = new List <ITokenNode>(); ITokenNode tokenNodeToStopAt = last.GetNextToken(); for (ITokenNode foundToken = first; foundToken != tokenNodeToStopAt; foundToken = foundToken.GetNextToken()) { a.Add(foundToken); } foreach (ITokenNode tokenNode in a) { LowLevelModificationUtil.DeleteChild(tokenNode); } } }
/// <summary> /// Moves the IStartRegion specified inside the next open curly bracket and moves the corresponding end region inside too. /// </summary> /// <param name="startRegionNode"> /// The node to move. /// </param> public static void MoveRegionInsideNextOpenCurlyBracket(IStartRegion startRegionNode) { using (WriteLockCookie.Create(true)) { ITokenNode newLocationTokenNode = Utils.GetFirstNonWhitespaceTokenToRight(startRegionNode.Message); // if its a start region there is probably a corresponding end region // find it, and move it inside the block // find the position to delete from ITokenNode startOfTokensToDelete = Utils.GetFirstNewLineTokenToLeft(startRegionNode.NumberSign); ITokenNode endOfTokensToDelete = Utils.GetFirstNewLineTokenToRight(startRegionNode.Message); ITokenNode startOfTokensToFormat = startOfTokensToDelete.GetPrevToken(); IEndRegion endRegionNode = startRegionNode.EndRegion; IStartRegion newStartRegion = startRegionNode.Copy(null); ITokenNode firstNonWhitespaceAfterBracket = Utils.GetFirstNonWhitespaceTokenToRight(newLocationTokenNode); LowLevelModificationUtil.AddChildBefore(firstNonWhitespaceAfterBracket, new[] { newStartRegion }); newStartRegion.InsertNewLineAfter(); LowLevelModificationUtil.DeleteChildRange(startOfTokensToDelete, endOfTokensToDelete); IStartRegion endOfTokensToFormat = newStartRegion; if (endRegionNode != null) { startOfTokensToDelete = Utils.GetFirstNewLineTokenToLeft(endRegionNode.NumberSign); endOfTokensToDelete = Utils.GetFirstNewLineTokenToRight(endRegionNode.NumberSign); IEndRegion newEndRegionNode = endRegionNode.Copy(null); ITokenNode newLineToken = Utils.GetFirstNonWhitespaceTokenToLeft(endRegionNode.NumberSign); LowLevelModificationUtil.AddChildBefore(newLineToken, new[] { newEndRegionNode }); newEndRegionNode.InsertNewLineAfter(); LowLevelModificationUtil.DeleteChildRange(startOfTokensToDelete, endOfTokensToDelete); endOfTokensToFormat = (IStartRegion)newLineToken; } ////CSharpFormatterHelper.FormatterInstance.Format(startOfTokensToFormat, endOfTokensToFormat); ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter; codeFormatter.Format(startOfTokensToFormat, endOfTokensToFormat); } }
protected override ITreeNode Move(Direction direction) { using (PsiTransactionCookie.CreateAutoCommitCookieWithCachesUpdate(myRuleDeclaration.GetPsiServices(), "Rearrange code")) { if (direction == Direction.Up) { var sibling = myRuleDeclaration.PrevSibling; while (sibling is IWhitespaceNode) { sibling = sibling.PrevSibling; } var ruleDeclaration = sibling as IRuleDeclaration; if (ruleDeclaration != null) { using (WriteLockCookie.Create()) { LowLevelModificationUtil.AddChildBefore(ruleDeclaration, myRuleDeclaration); LowLevelModificationUtil.AddChildBefore(ruleDeclaration, new NewLine("\r\n")); } } } if (direction == Direction.Down) { var sibling = myRuleDeclaration.NextSibling; while (sibling is IWhitespaceNode) { sibling = sibling.NextSibling; } var ruleDeclaration = sibling as IRuleDeclaration; if (ruleDeclaration != null) { using (WriteLockCookie.Create()) { LowLevelModificationUtil.AddChildAfter(ruleDeclaration, myRuleDeclaration); LowLevelModificationUtil.AddChildAfter(ruleDeclaration, new NewLine("\r\n")); } } } } return(myRuleDeclaration); }
/// <summary> /// Single line comments must begin with single space. /// </summary> /// <param name="node"> /// The node to use. /// </param> public static void SingleLineCommentsMustBeginWithSingleSpace(ITreeNode node) { for (ITreeNode currentNode = node; currentNode != null; currentNode = currentNode.NextSibling) { if (currentNode is ICommentNode && !(currentNode is IDocCommentNode)) { ICommentNode commentNode = currentNode as ICommentNode; if (commentNode.GetTokenType() == CSharpTokenType.END_OF_LINE_COMMENT && !(commentNode.Parent is ICSharpFile)) { string originalCommentText = commentNode.CommentText; // This check is to exclude comments starting with //// if (!originalCommentText.StartsWith("//")) { int originalCommentTextLength = originalCommentText.Length; string trimmedCommentText = originalCommentText.TrimStart(' '); int trimmedCommentTextLength = trimmedCommentText.Length; if (trimmedCommentTextLength != originalCommentTextLength - 1) { using (WriteLockCookie.Create(true)) { string newText = string.Format("// {0}", trimmedCommentText); ICommentNode newCommentNode = (ICommentNode) CSharpTokenType.END_OF_LINE_COMMENT.Create( new JetBrains.Text.StringBuffer(newText), new TreeOffset(0), new TreeOffset(newText.Length)); LowLevelModificationUtil.ReplaceChildRange(currentNode, currentNode, new ITreeNode[] { newCommentNode }); currentNode = newCommentNode; } } } } } if (currentNode.FirstChild != null) { SingleLineCommentsMustBeginWithSingleSpace(currentNode.FirstChild); } } }