public static IClrTypeName GetClassNameAppropriateToLocation(ISolution solution, ITextControl textControl)
{
IDeclaredElement documentElement = TextControlToPsi.GetContainingTypeOrTypeMember(solution, textControl);
if (documentElement == null)
{
return(FindFirstTypeInFile(solution, textControl.Document));
}
//AppendLineToOutputWindow("Element at cursor is of type " + documentElement.GetType().Name);
IClrTypeName clrTypeName = null;
if (documentElement is IClass)
{
clrTypeName = ((IClass)documentElement).GetClrName();
}
if (documentElement is ITypeElement && clrTypeName == null)
{
var containingType = ((ITypeElement)documentElement).GetContainingType();
if (containingType != null)
{
clrTypeName = containingType.GetClrName();
}
}
if (clrTypeName == null)
{
AppendLineToOutputWindow(solution.Locks, "Unable to identify the class from current cursor position.");
return(FindFirstTypeInFile(solution, textControl.Document));
}
return(clrTypeName);
}
public override ISpecificCodeCompletionContext GetCompletionContext(CodeCompletionContext context)
{
var relatedText = string.Empty;
var nodeUnderCursor = TextControlToPsi.GetElement<ITreeNode>(context.Solution, context.TextControl);
var interestingNode = GetInterestingNode(nodeUnderCursor);
if (interestingNode == null)
return null;
var ranges = GetTextLookupRanges(context, nodeUnderCursor.GetDocumentRange());
if (interestingNode is GherkinStep step)
{
var stepTextRange = step.GetStepTextRange();
if (IsCursorBeforeNode(context, stepTextRange))
return null;
relatedText = step.GetStepTextBeforeCaret(context.CaretDocumentOffset);
if (IsCursorAfterNode(context, stepTextRange))
{
stepTextRange = stepTextRange.ExtendRight(context.CaretDocumentOffset.Offset - stepTextRange.EndOffset.Offset);
relatedText += " ";
}
var replaceRange = stepTextRange;
var insertRange = stepTextRange.SetEndTo(context.SelectedRange.EndOffset);
ranges = new TextLookupRanges(insertRange, replaceRange);
}
return new GherkinSpecificCodeCompletionContext(context, ranges, interestingNode, relatedText);
}
public override bool IsAvailable(IDataContext dataContext)
{
var textControl = dataContext.GetData(TextControl.DataContext.DataConstants.TEXT_CONTROL);
ISolution solution = dataContext.GetData(ProjectModel.DataContext.DataConstants.SOLUTION);
var token = TextControlToPsi.GetSourceTokenAtCaret(solution, textControl);
RuleDeclaration ruleDeclaration = null;
if (token.Parent is IRuleDeclaredName)
{
ruleDeclaration = token.Parent.Parent as RuleDeclaration;
}
else if (token.Parent is IRuleName)
{
var reference = (token.Parent as IRuleName).RuleNameReference;
var declaredElement = reference.Resolve().DeclaredElement;
ruleDeclaration = declaredElement as RuleDeclaration;
}
else if (token.Parent is IPathName)
{
var reference = (token.Parent as IPathName).RuleNameReference;
var declaredElement = reference.Resolve().DeclaredElement;
ruleDeclaration = declaredElement as RuleDeclaration;
}
if (ruleDeclaration != null)
{
var psiFile = ruleDeclaration.GetContainingNode <PsiFile>();
if (psiFile != null)
{
psiFile.CollectDerivedElements(ruleDeclaration);
}
return(HasDerivedElements(ruleDeclaration));
}
return(false);
}
/*
* public static IEnumerable<ITypeElement> GetTypesInFile(IProjectFile projectFile)
* {
* var sourceFile = projectFile.ToSourceFile();
* if (sourceFile == null)
* return new List<ITypeElement>();
*
* var services = sourceFile.GetPsiServices();
* return services.Symbols.GetTypesAndNamespacesInFile(sourceFile).OfType<ITypeElement>();
* }
*/
public static IDeclaredElement FindDeclaredElementInFile(ISolution solution, IDocument document,
int declarationSequencePosition)
{
List <string> typesFound = new List <string>();
for (int i = document.DocumentRange.StartOffset; i < document.DocumentRange.EndOffset; i++)
{
IDeclaredElement typeInFile =
TextControlToPsi.GetContainingTypeOrTypeMember(solution, new DocumentOffset(document, i));
if (typeInFile != null)
{
if (!typesFound.Contains(typeInFile.ShortName))
{
typesFound.Add(typeInFile.ShortName);
}
if (typesFound.Count == declarationSequencePosition)
{
return(typeInFile);
}
}
}
return(null);
}
public static ICSharpStatement FixExpressionToStatement(DocumentRange expressionRange, [NotNull] IPsiServices psiServices)
{
var solution = psiServices.Solution;
var offset = expressionRange.TextRange.StartOffset;
var document = expressionRange.Document;
var expressions = TextControlToPsi.GetElements <IRazorImplicitExpression>(solution, document, offset);
foreach (var razorExpression in expressions)
{
var razorRange = razorExpression.GetDocumentRange();
const string commandName = "Replacing razor expression with statement";
using (solution.CreateTransactionCookie(
DefaultAction.Commit, commandName, NullProgressIndicator.Instance))
{
razorRange.Document.ReplaceText(razorRange.TextRange, "@using(null){}");
}
solution.GetPsiServices().Files.CommitAllDocuments();
var statements = TextControlToPsi.GetElements <IUsingStatement>(solution, document, offset);
foreach (var razorStatement in statements)
{
return(razorStatement);
}
break;
}
return(null);
}
private static PostfixTemplateContext TryReparseWith([NotNull] ISolution solution, [NotNull] ITextControl textControl, [NotNull] string reparseString)
{
var offset = textControl.Caret.Offset();
var document = textControl.Document;
try
{
document.InsertText(offset, reparseString);
solution.GetPsiServices().Files.CommitAllDocuments();
foreach (var position in TextControlToPsi.GetElements <ITreeNode>(solution, document, offset))
{
var templateContextFactory = LanguageManager.Instance.TryGetService <IPostfixTemplateContextFactory>(position.Language);
if (templateContextFactory != null)
{
var executionContext = new PostfixTemplateExecutionContext(
solution, textControl, position.GetSettingsStore(), reparseString, false);
return(templateContextFactory.TryCreate(position, executionContext));
}
}
return(null);
}
finally
{
var reparseRange = TextRange.FromLength(offset, reparseString.Length);
document.DeleteText(reparseRange);
}
}
// protected override ICSharpStatement DecorateStatement(CSharpElementFactory factory,
// ICSharpStatement statement)
// {
// var info = (ValidatePostfixTemplateInfo) Info;
// var type = TypeFactory.CreateType(info.ValidatorTypes.First());
// var newStatement = factory.CreateStatement("var validator = new $0();", type);
// var statementsOwner = StatementsOwnerNavigator.GetByStatement(statement);
// return statementsOwner.AddStatementBefore(newStatement, statement);
// }
protected override void AfterComplete(ITextControl textControl, ICSharpStatement statement, Suffix suffix)
{
var expressionMarker = statement.GetDocumentRange().CreateRangeMarker();
var solution = statement.GetSolution();
ExecuteRefactoring(textControl, statement.Descendants <IObjectCreationExpression>().First(), () =>
{
var documentRange = expressionMarker.DocumentRange;
if (!documentRange.IsValid())
{
return;
}
solution.GetPsiServices().Files.CommitAllDocuments();
var element = TextControlToPsi.GetElement <ICSharpStatement>(solution, documentRange.EndOffset);
if (element == null)
{
return;
}
textControl.Caret.MoveTo(element.GetDocumentRange().TextRange.EndOffset,
CaretVisualPlacement.DontScrollIfVisible);
});
// base.AfterComplete(textControl, statement, suffix);
}
protected override IList <IDataRule> ProvideContextData(ITextControl textControl, IProject project,
ISolution solution)
{
var dataRules = base.ProvideContextData(textControl, project, solution);
var ret = myDrivenTextBase.ProvideContextData(project, textControl);
dataRules.AddRange(ret);
if (!ret.IsEmpty())
{
return(dataRules);
}
dataRules.AddRule("Test", DocumentModelDataConstants.DOCUMENT, textControl.Document);
dataRules.AddRule("Test", ProjectModelDataConstants.PROJECT, project);
dataRules.AddRule("Test", PsiDataConstants.REFERENCE, ctx =>
{
var references = TextControlToPsi.GetReferencesAtCaret(solution, textControl);
return(references != null ? references.FirstOrDefault() : null);
});
dataRules.AddRule("Test", PsiDataConstants.REFERENCES,
ctx => TextControlToPsi.GetReferencesAtCaret(solution, textControl));
dataRules.AddRule("Test", ProjectModelDataConstants.PROJECT_MODEL_ELEMENT, ctx => null);
dataRules.AddRule("Test", PsiDataConstants.SELECTED_EXPRESSION,
ctx => ExpressionSelectionUtil.GetSelectedExpression <ITreeNode>(Solution, textControl, false));
dataRules.AddRule("Test", DocumentModelDataConstants.EDITOR_CONTEXT, ctx =>
textControl.Selection.HasSelection()
? new DocumentEditorContext(textControl.Selection.OneDocumentRangeWithCaret())
: null);
return(dataRules);
}
private IList <IPostfixLookupItem> TryReparseWith([NotNull] ISolution solution, [NotNull] ITextControl textControl,
[NotNull] string templateName, [NotNull] string reparseString)
{
var offset = textControl.Caret.Offset();
var document = textControl.Document;
try
{
document.InsertText(offset, reparseString);
solution.GetPsiServices().CommitAllDocuments();
var itemsOwner = myItemsOwnerFactory.CreateLookupItemsOwner(textControl);
var executionContext = new PostfixExecutionContext(
myLifetime, solution, textControl, itemsOwner, reparseString, false);
foreach (var position in TextControlToPsi.GetElements <ITokenNode>(solution, document, offset))
{
var postfixContext = myTemplatesManager.IsAvailable(position, executionContext);
if (postfixContext == null)
{
continue;
}
return(myTemplatesManager.CollectItems(postfixContext, templateName: templateName));
}
return(null);
}
finally
{
var reparseRange = TextRange.FromLength(offset, reparseString.Length);
document.DeleteText(reparseRange);
}
}
private IReferenceExpression FindReferenceExpression([NotNull] ITextControl textControl, [NotNull] ISolution solution)
{
var dotRange = myDotRangeMarker.DocumentRange;
if (!dotRange.IsValid())
{
return(null);
}
var tokenOffset = dotRange.TextRange.StartOffset;
foreach (var token in TextControlToPsi.GetElements <ITokenNode>(solution, textControl.Document, tokenOffset))
{
if (token.GetTokenType() == CSharpTokenType.DOT)
{
var expression = token.Parent as IReferenceExpression;
if (expression != null)
{
return(expression);
}
}
}
return(null);
}
private ITreeNode FindCurrentTreeNode(IDocument document)
{
var textControl =
_textControlManager.TextControls.FirstOrDefault(
tc => tc.Document.Moniker.Equals(document.Moniker));
return(textControl == null ? null : TextControlToPsi.GetElement <ITreeNode>(_solution, textControl));
}
public IRearrangeable CreateElement(ISolution solution, ITextControl textControl)
{
foreach (IRuleDeclaration ruleDeclaration in TextControlToPsi.GetElements <IRuleDeclaration>(solution, textControl))
{
return(new RearrangeableRuleDeclaration(ruleDeclaration));
}
return(null);
}
public static IDataContext Create(Lifetime lifetime, ITextControl textControl, ISolution solution)
{
var provider = new List <IDataRule>();
provider.AddRule("Test", PsiDataConstants.DECLARED_ELEMENTS, ctx => TextControlToPsi.GetDeclaredElements(solution, textControl).ToDeclaredElementsDataConstant());
provider.AddRule("Test", JetBrains.TextControl.DataContext.TextControlDataConstants.TEXT_CONTROL, textControl);
provider.AddRule("Test", JetBrains.ProjectModel.DataContext.ProjectModelDataConstants.SOLUTION, solution);
provider.AddRule("Test", PsiDataConstants.REFERENCE, ctx => TextControlToPsi.GetReferencesAtCaret(solution, textControl).FirstOrDefault());
provider.AddRule("Test", PsiDataConstants.SELECTED_EXPRESSION, ctx => ExpressionSelectionUtil.GetSelectedExpression <ITreeNode>(solution, textControl, false));
return(Shell.Instance.GetComponent <IActionManager>().DataContexts.CreateWithDataRules(lifetime, provider));
}
private ITreeNode GetTreeNode([NotNull] ITextControl textControl)
{
ITreeNode treeNode = null;
if (ReentrancyGuard.Current.CanExecuteNow)
{
ReadLockCookie.GuardedExecute(
() => { treeNode = TextControlToPsi.GetElement <ITreeNode>(_solution, textControl); });
}
return(treeNode);
}
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 ICSharpTypeDeclaration FindFirstCharpTypeDeclarationInDocument(ISolution solution, IDocument document)
{
for (int i = document.DocumentRange.StartOffset; i < document.DocumentRange.EndOffset; i++)
{
var declaration = TextControlToPsi.GetElements <ICSharpTypeDeclaration>(solution, new DocumentOffset(document, i)).FirstOrDefault();
if (declaration != null)
{
return(declaration);
}
}
return(null);
}
private IEnumerable <ITypeElement> GetTypesFromNamespace(ITextControl textControl, ISolution solution)
{
var symbolCache = solution.GetPsiServices().Symbols;
var namespaceDeclaration = TextControlToPsi.GetElementFromCaretPosition <INamespaceDeclaration>(solution, textControl);
if (namespaceDeclaration?.DeclaredElement != null)
{
var symbolScope = symbolCache.GetSymbolScope(LibrarySymbolScope.FULL, caseSensitive: true);
return(namespaceDeclaration.DeclaredElement.GetNestedTypeElements(symbolScope));
}
return(EmptyList <ITypeElement> .InstanceList);
}
public override bool IsApplicable(IDataContext dataContext)
{
var textControl = dataContext.GetData(TextControl.DataContext.DataConstants.TEXT_CONTROL);
ISolution solution = dataContext.GetData(ProjectModel.DataContext.DataConstants.SOLUTION);
var token = TextControlToPsi.GetSourceTokenAtCaret(solution, textControl);
if ((token.Parent is IRuleName) || (token.Parent is IRuleDeclaredName) || (token.Parent is PathName))
{
return(true);
}
return(false);
}
private ITreeNode GetTreeNode([NotNull] ITextControl textControl)
{
var treeNode = TextControlToPsi.GetElement <ITreeNode>(_solution, textControl);
if (treeNode.IsWhitespaceToken() && treeNode.NextSibling != null)
{
treeNode = treeNode.NextSibling;
}
if (treeNode != null && CSharpTokenType.DOT == treeNode.GetTokenType())
{
treeNode = treeNode.NextSibling;
}
return(treeNode);
}
protected override void DoTest(IProject testProject)
{
CaretPosition caretPos = GetCaretPosition();
using (ITextControl textControl = OpenTextControl(testProject, caretPos))
{
IDeclaredElement declaredElement = TextControlToPsi.GetDeclaredElements(Solution, textControl).FirstOrDefault();
Assert.IsNotNull(declaredElement);
Solution.GetComponent <CallRenameUtil>().CallRename(declaredElement, textControl, "xxx");
CheckTextControl(textControl);
}
}
public override bool IsApplicable(IDataContext dataContext)
{
//return IsAvailable(dataContext);
var textControl = dataContext.GetData(TextControl.DataContext.DataConstants.TEXT_CONTROL);
ISolution solution = dataContext.GetData(ProjectModel.DataContext.DataConstants.SOLUTION);
var token = TextControlToPsi.GetSourceTokenAtCaret(solution, textControl);
if ((token.Parent is IReferenceName) || token.Parent is IClassDeclaration || token.Parent is IConstructorDeclaration || token.Parent is IMethodDeclaration || token.Parent is IInterfaceDeclaration)
{
return(true);
}
return(false);
}
public HotspotItems GetLookupItems(IHotspotContext context, IList <string> arguments)
{
var method = TextControlToPsi.GetContainingTypeOrTypeMember(context.SessionContext.Solution, context.SessionContext.TextControl);
if (method is IMethod)
{
var lookupItems = new List <ILookupItem>();
var item = new TextLookupItem(((IMethod)method).ReturnType.GetPresentableName(method.PresentationLanguage));
lookupItems.Add(item);
var hotSpotItems = new HotspotItems(lookupItems);
return(hotSpotItems);
}
return(null);
}
public bool IsAvailable(IUserDataHolder cache)
{
if (!myProvider.Solution.GetComponent <MarksService>().Enabled.Value)
{
return(false);
}
bool x;
var declaredElements = TextControlToPsi.GetDeclaredElements(myProvider.Solution, myProvider.Document, myProvider.CaretOffset, out x);
foreach (var declaredElement in declaredElements)
{
if (declaredElement.ShortName == ZoneConstants.ZoneAttributeName)
{
return(true);
}
}
return(false);
}
private static bool TryPlaceCaretSmart([NotNull] ISolution solution, [NotNull] ITextControl textControl,
[NotNull] PsiLanguageType language, TextRange range)
{
foreach (var tokenNode in TextControlToPsi.GetElements <ITokenNode>(solution, textControl.Document, range.EndOffset))
{
if (!tokenNode.Language.IsLanguage(language))
{
continue;
}
var tokenType = tokenNode.GetTokenType();
if (tokenType == CSharpTokenType.LT)
{
var typeArguments = tokenNode.Parent as ITypeArgumentList;
if (typeArguments == null)
{
continue;
}
var endOffset = tokenNode.GetDocumentRange().TextRange.EndOffset;
textControl.Caret.MoveTo(endOffset, CaretVisualPlacement.DontScrollIfVisible);
return(true);
}
if (tokenType == CSharpTokenType.LPARENTH)
{
var invocation = tokenNode.Parent as IInvocationExpression;
if (invocation == null || invocation.RPar == null)
{
continue;
}
var reference = invocation.InvocationExpressionReference;
if (reference.Resolve().ResolveErrorType == ResolveErrorType.OK)
{
var offset = invocation.RPar.GetDocumentRange().TextRange.EndOffset;
textControl.Caret.MoveTo(offset, CaretVisualPlacement.DontScrollIfVisible);
return(true);
}
}
}
return(false);
}
protected override Action <JetBrains.TextControl.ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
if (!this.Highlighting.IsValid())
{
return(null);
}
var node = this.Highlighting.Node;
var badWordTextRange = this.Highlighting.CalculateRange().TextRange;
var newText = StringUtil.ReplaceSection(node.GetText(), this.Suggestion, badWordTextRange.StartOffset - node.GetDocumentRange().TextRange.StartOffset, badWordTextRange.Length);
if (node is IIdentifier)
{
return(textControl =>
{
var declaredIdentifier = TextControlToPsi.GetDeclaredElements(solution, textControl).FirstOrDefault();
solution.GetComponent <RenameRefactoringExecutor>().Execute(declaredIdentifier, textControl, newText);
});
}
if (node is IComment)
{
var elementFactory = CSharpElementFactory.GetInstance(node.GetPsiModule());
var newComment = elementFactory.CreateComment(newText);
ModificationUtil.ReplaceChild(node, newComment);
return(null);
}
if (node is IExpression)
{
var expression = node as IExpression;
if (expression.ConstantValue.IsString())
{
var elementFactory = CSharpElementFactory.GetInstance(node.GetPsiModule());
var newStringLiteral = elementFactory.CreateExpression("$0", newText);
ModificationUtil.ReplaceChild(node, newStringLiteral);
return(null);
}
}
return(null);
}
public IEnumerable <ITypeElement> GetTypesFromCaretOrFile(ITextControl textControl, ISolution solution)
{
var classDeclaration = TextControlToPsi.GetElementFromCaretPosition <ITypeDeclaration>(solution, textControl);
if (classDeclaration != null)
{
return new[] { classDeclaration.DeclaredElement }
}
;
var symbolCache = solution.GetPsiServices().Symbols;
var psiSourceFile = textControl.Document.GetPsiSourceFile(solution);
if (psiSourceFile != null)
{
return(symbolCache.GetTypesAndNamespacesInFile(psiSourceFile).OfType <ITypeElement>());
}
return(EmptyList <ITypeElement> .InstanceList);
}
private static IOccurence GetOccurence(FileLocationInfo location, bool bindToPsi)
{
var projectFile = location.ProjectFile;
if (bindToPsi)
{
var sourceFile = projectFile.ToSourceFile();
if (sourceFile != null)
{
DeclaredElementEnvoy <INamespace> boundNamespace;
DeclaredElementEnvoy <ITypeElement> boundTypeElement;
DeclaredElementEnvoy <ITypeMember> boundTypeMember;
TextControlToPsi.BindToPsi(sourceFile, new TextRange(location.CaretOffset), out boundTypeMember, out boundTypeElement, out boundNamespace);
if (boundTypeMember != null || boundTypeElement != null)
{
var declaredElement = ((IDeclaredElementEnvoy)boundTypeMember ?? boundTypeElement).GetValidDeclaredElement();
if (declaredElement != null)
{
return(new CustomRangeOccurence(sourceFile, new DocumentRange(sourceFile.Document, new TextRange(location.CaretOffset)), new OccurencePresentationOptions {
ContainerStyle = ContainerDisplayStyle.File
}));
}
}
}
}
//project file can loose its owner project (i.e. micsFilesProject) during provision tab navigation
if (projectFile.GetProject() == null)
{
return(new DecompiledFileOccurence(location.FileSystemPath, new TextRange(location.CaretOffset), location.CachedPresentation, projectFile.GetSolution()));
}
if (projectFile.IsValid())
{
return(new ProjectItemOccurence(projectFile, new OccurencePresentationOptions {
ContainerStyle = ContainerDisplayStyle.NoContainer
}));
}
return(null);
}
protected override void DoTest(Lifetime lifetime, IProject testProject)
{
var textControl = OpenTextControl(TestLifetime);
var document = textControl.Document;
var projectFile = Solution.GetComponent <DocumentManager>().TryGetProjectFile(document);
Assert.IsNotNull(projectFile, "projectFile == null");
var context = CreateDataContext(textControl);
var declaredElement = TextControlToPsi.GetDeclaredElements(Solution, textControl).SingleOrDefault();
Exception exception = null;
if (declaredElement != null)
{
try
{
TestAdditionalInfo(declaredElement, projectFile);
}
catch (Exception e)
{
exception = e;
}
}
var quickDocService = Solution.GetComponent <IQuickDocService>();
Assert.IsTrue(quickDocService.CanShowQuickDoc(context), "No QuickDoc available");
quickDocService.ResolveGoto(context, (presenter, language) => ExecuteWithGold(projectFile, writer =>
{
var text = presenter.GetHtml(language).Text?.Text;
Assert.NotNull(text);
var startIdx = text.IndexOf(" <head>", StringComparison.Ordinal);
var endIdx = text.IndexOf("</head>", StringComparison.Ordinal) + "</head>".Length;
Assert.AreEqual(string.CompareOrdinal(text, endIdx, "\n<body>", 0, "\n<body>".Length), 0);
writer.Write(text.Remove(startIdx, endIdx - startIdx + 1));
}));
if (exception != null)
{
throw exception;
}
}
protected override Action <ITextControl> ExecutePsiTransaction(ISolution solution, IProgressIndicator progress)
{
if (!Highlighting.IsValid())
{
return(null);
}
var node = Highlighting.Node;
var badWordTextRange = Highlighting.Range.TextRange;
var newText = StringUtil.ReplaceSection(
node.GetText(),
Suggestion,
badWordTextRange.StartOffset - node.GetDocumentRange().TextRange.StartOffset,
badWordTextRange.Length
);
if (node is IIdentifier)
{
return(textControl => {
var declaredIdentifier = TextControlToPsi.GetDeclaredElements(solution, textControl)
.FirstOrDefault();
solution.GetComponent <RenameRefactoringExecutor>().Execute(declaredIdentifier, textControl, newText);
});
}
if (node is IComment)
{
var newElement = CreateNode(node, newText);
ModificationUtil.ReplaceChild(node, newElement);
return(null);
}
if (JavaScriptUtil.IsStringLiteral(node))
{
var newElement = CreateNode(node, newText);
ModificationUtil.ReplaceChild(node, newElement);
return(null);
}
return(null);
}
public override HotspotItems GetLookupItems(IHotspotContext context)
{
var document = context.ExpressionRange.Document;
if (document == null)
{
return(null);
}
var method = TextControlToPsi.GetContainingTypeOrTypeMember(context.SessionContext.Solution, document, context.ExpressionRange.StartOffsetRange().TextRange.StartOffset) as IMethod;
if (method != null)
{
var lookupItems = new List <ILookupItem>();
var methodReturnTypeName = method.ReturnType.GetPresentableName(method.PresentationLanguage);
var item = new TextLookupItem(methodReturnTypeName);
lookupItems.Add(item);
var hotSpotItems = new HotspotItems(lookupItems);
return(hotSpotItems);
}
return(null);
}
