public override void Complete(CompletionContext context) { var invokeSignature = delegateType.GetMethods(m => m.Name == "Invoke").Single(); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); var builder = refactoringContext.CreateTypeSystemAstBuilder(); var handlerName = eventDefinition.Name; var throwStatement = new ThrowStatement(); var decl = new MethodDeclaration { ReturnType = refactoringContext.CreateShortType(invokeSignature.ReturnType), Name = handlerName, Body = new BlockStatement { throwStatement } }; decl.Parameters.AddRange(invokeSignature.Parameters.Select(builder.ConvertParameter)); if (eventDefinition.IsStatic) decl.Modifiers |= Modifiers.Static; throwStatement.Expression = new ObjectCreateExpression(refactoringContext.CreateShortType("System", "NotImplementedException")); // begin insertion using (context.Editor.Document.OpenUndoGroup()) { context.Editor.Document.Replace(context.StartOffset, context.Length, handlerName); context.EndOffset = context.StartOffset + handlerName.Length; using (var script = refactoringContext.StartScript()) { script.InsertWithCursor(this.DisplayText, Script.InsertPosition.Before, decl) // TODO : replace with Link, once that is implemented .ContinueScript(() => script.Select(throwStatement)); } } }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.ShowTypeParameterConstraints = false; b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~(Modifiers.Virtual | Modifiers.Abstract); entityDeclaration.Modifiers |= Modifiers.Override; if (!this.Entity.IsAbstract) { // modify body to call the base method if (this.Entity.SymbolKind == SymbolKind.Method) { var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, ParametersToExpressions(this.Entity)); var body = entityDeclaration.GetChildByRole(Roles.Body); body.Statements.Clear(); if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void)) body.Statements.Add(new ExpressionStatement(baseCall)); else body.Statements.Add(new ReturnStatement(baseCall)); } else if (this.Entity.SymbolKind == SymbolKind.Indexer || this.Entity.SymbolKind == SymbolKind.Property) { Expression baseCall; if (this.Entity.SymbolKind == SymbolKind.Indexer) baseCall = new BaseReferenceExpression().Indexer(ParametersToExpressions(this.Entity)); else baseCall = new BaseReferenceExpression().Member(this.Entity.Name); var getterBody = entityDeclaration.GetChildByRole(PropertyDeclaration.GetterRole).Body; if (!getterBody.IsNull) { getterBody.Statements.Clear(); getterBody.Add(new ReturnStatement(baseCall.Clone())); } var setterBody = entityDeclaration.GetChildByRole(PropertyDeclaration.SetterRole).Body; if (!setterBody.IsNull) { setterBody.Statements.Clear(); setterBody.Add(new AssignmentExpression(baseCall.Clone(), new IdentifierExpression("value"))); } } } var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop(); var segmentDict = SegmentTrackingOutputFormatter.WriteNode(w, entityDeclaration, formattingOptions, context.Editor.Options); using (document.OpenUndoGroup()) { string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions); } }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~Modifiers.VisibilityMask; // remove visiblity entityDeclaration.Modifiers |= Modifiers.Partial; var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = CSharpFormattingPolicies.Instance.GetProjectOptions(contextAtCaret.Compilation.GetProject()); var segmentDict = SegmentTrackingOutputFormatter.WriteNode( w, entityDeclaration, formattingOptions.OptionsContainer.GetEffectiveOptions(), context.Editor.Options); using (document.OpenUndoGroup()) { string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions.OptionsContainer); } }
protected void TestTextInsert(string file, char completionChar, ICompletionItemList list, ICompletionItem item, string expectedOutput, int expectedOffset) { int insertionPoint = file.IndexOf('|'); if (insertionPoint < 0) Assert.Fail("insertionPoint not found in text!"); this.textEditor.Document.Text = file.Replace("|", ""); this.textEditor.Caret.Offset = insertionPoint; this.textEditor.CreateParseInformation(); CompletionContext context = new CompletionContext() { Editor = this.textEditor, CompletionChar = completionChar, StartOffset = textEditor.Caret.Offset, EndOffset = textEditor.Caret.Offset }; list.Complete(context, item); if (!context.CompletionCharHandled && context.CompletionChar != '\n') this.textEditor.Document.Insert(this.textEditor.Caret.Offset, completionChar + ""); string insertedText = this.textEditor.Document.GetText(insertionPoint, this.textEditor.Document.TextLength - file.Length + 1); Assert.AreEqual(expectedOutput, insertedText); Assert.AreEqual(insertionPoint + expectedOffset, textEditor.Caret.Offset); }
public void Insert(CompletionContext context, ICompletionItem item) { if (item == null) throw new ArgumentNullException("item"); if (!(item is OverrideCompletionItem)) throw new ArgumentException("item is not an OverrideCompletionItem"); OverrideCompletionItem completionItem = item as OverrideCompletionItem; ITextEditor textEditor = context.Editor; IEditorUIService uiService = textEditor.GetService(typeof(IEditorUIService)) as IEditorUIService; if (uiService == null) return; ParseInformation parseInfo = ParserService.GetParseInformation(textEditor.FileName); if (parseInfo == null) return; CodeGenerator generator = parseInfo.CompilationUnit.Language.CodeGenerator; IClass current = parseInfo.CompilationUnit.GetInnermostClass(textEditor.Caret.Line, textEditor.Caret.Column); ClassFinder finder = new ClassFinder(current, textEditor.Caret.Line, textEditor.Caret.Column); if (current == null) return; using (textEditor.Document.OpenUndoGroup()) { ITextAnchor startAnchor = textEditor.Document.CreateAnchor(textEditor.Caret.Offset); startAnchor.MovementType = AnchorMovementType.BeforeInsertion; ITextAnchor endAnchor = textEditor.Document.CreateAnchor(textEditor.Caret.Offset); endAnchor.MovementType = AnchorMovementType.AfterInsertion; MethodDeclaration member = (MethodDeclaration)generator.GetOverridingMethod(completionItem.Member, finder); string indent = DocumentUtilitites.GetWhitespaceBefore(textEditor.Document, textEditor.Caret.Offset); string codeForBaseCall = generator.GenerateCode(member.Body.Children.OfType<AbstractNode>().First(), ""); string code = generator.GenerateCode(member, indent); int marker = code.IndexOf(codeForBaseCall); textEditor.Document.Insert(startAnchor.Offset, code.Substring(0, marker).TrimStart()); ITextAnchor insertionPos = textEditor.Document.CreateAnchor(endAnchor.Offset); insertionPos.MovementType = AnchorMovementType.BeforeInsertion; InsertionContext insertionContext = new InsertionContext(textEditor.GetService(typeof(TextArea)) as TextArea, startAnchor.Offset); AbstractInlineRefactorDialog dialog = new OverrideEqualsGetHashCodeMethodsDialog(insertionContext, textEditor, startAnchor, endAnchor, insertionPos, current, completionItem.Member as IMethod, codeForBaseCall.Trim()); dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog); textEditor.Document.InsertNormalized(endAnchor.Offset, Environment.NewLine + code.Substring(marker + codeForBaseCall.Length)); insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog); insertionContext.RaiseInsertionCompleted(EventArgs.Empty); } }
public override void Complete(CompletionContext context, ICompletionItem item) { base.Complete(context, item); if (item.Text == "..") { VBNetCompletionBinding.Instance.CtrlSpace(context.Editor); } }
public void ListCompleteMethodCallsCompletionItemCompleteMethod() { CompletionContext context = new CompletionContext(); XmlCompletionItemCollection completionItems = new XmlCompletionItemCollection(); completionItems.Complete(context, this); Assert.AreSame(contextPassedToCompleteMethod, context); }
public override void Complete(CompletionContext context) { if (addType) { MarkAsUsed(); string newText = Entity.DeclaringType.Name + "." + Text; context.Editor.Document.Replace(context.StartOffset, context.Length, newText); context.EndOffset = context.StartOffset + newText.Length; } else base.Complete(context); }
public override void Complete(CompletionContext context) { int index = CompletionText.IndexOf('|'); if (index > -1) { context.Editor.Document.Replace(context.StartOffset, context.Length, CompletionText.Remove(index, 1)); context.Editor.Caret.Offset = context.StartOffset + index; } else { base.Complete(context); } }
public override void Complete(CompletionContext context) { context.Editor.Document.Replace(context.StartOffset, context.Length, insertionText); context.EndOffset = context.StartOffset + insertionText.Length; if (insertUsing != null) { SD.Log.Debug("Insert using '" + insertUsing + "'"); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); using (var script = refactoringContext.StartScript()) { UsingHelper.InsertUsing(refactoringContext, script, new UsingDeclaration(insertUsing)); } } }
public override void Complete(CompletionContext context) { if (isUrl) base.Complete(context); else { ITextEditor editor = context.Editor; string newText = "clr-namespace:" + @namespace; if (!string.IsNullOrEmpty(assembly)) newText += ";assembly=" + assembly; editor.Document.Replace(context.StartOffset, context.Length, newText); context.EndOffset = context.StartOffset + newText.Length; } }
public override void Complete(CompletionContext context) { using (EditStringResourceDialog dialog = new EditStringResourceDialog(this.content, this.preEnteredName, null, true)) { dialog.Text = this.Description; if (dialog.ShowDialog(WorkbenchSingleton.MainWin32Window) != DialogResult.OK) { return; } this.content.Add(dialog.Key, dialog.Value); this.CompleteInternal(context, dialog.Key); } }
protected void CompleteInternal(CompletionContext context, string key) { string insertString; if (this.outputVisitor != null) { PrimitiveExpression pre = new PrimitiveExpression(key, key); pre.AcceptVisitor(this.outputVisitor, null); insertString = this.outputVisitor.Text; } else { insertString = key; } context.Editor.Document.Replace(context.StartOffset, context.Length, insertString); context.EndOffset = context.StartOffset + insertString.Length; }
public override void Complete(CompletionContext context) { var invokeSignature = delegateType.GetMethods(m => m.Name == "Invoke").Single(); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); var builder = refactoringContext.CreateTypeSystemAstBuilder(); string handlerName; bool isStatic; if (eventDefinition != null) { handlerName = eventDefinition.Name; isStatic = eventDefinition.IsStatic; } else { handlerName = varName; isStatic = callingMember.IsStatic; } var throwStatement = new ThrowStatement(); var decl = new MethodDeclaration { ReturnType = refactoringContext.CreateShortType(invokeSignature.ReturnType), Name = handlerName, Body = new BlockStatement { throwStatement } }; decl.Parameters.AddRange(invokeSignature.Parameters.Select(builder.ConvertParameter)); if (isStatic) decl.Modifiers |= Modifiers.Static; throwStatement.Expression = new ObjectCreateExpression(refactoringContext.CreateShortType("System", "NotImplementedException")); // begin insertion using (context.Editor.Document.OpenUndoGroup()) { context.Editor.Document.Replace(context.StartOffset, context.Length, handlerName + ";"); context.EndOffset = context.StartOffset + handlerName.Length; var loc = context.Editor.Document.GetLocation(context.StartOffset + handlerName.Length / 2 + 1); var parseInfo = SD.ParserService.Parse(context.Editor.FileName, context.Editor.Document) as CSharpFullParseInformation; if (parseInfo == null) return; using (var script = refactoringContext.StartScript()) { var node = parseInfo.SyntaxTree.GetNodeAt(loc, n => n is Identifier || n is IdentifierExpression); if (node == null) return; script.InsertWithCursor(this.DisplayText, Script.InsertPosition.Before, decl) .ContinueScript(() => script.Link(decl.NameToken, node).ContinueScript(() => script.Select(throwStatement))); } } }
public void OverrideAbstractMethod() { CompletionContext context = new CompletionContext(); context.Editor = textEditor; context.StartOffset = textEditor.Caret.Offset; context.EndOffset = textEditor.Caret.Offset; ICompletionItem item = textEditor.LastCompletionItemList.Items.First(i=>i.Text == "AbstractMethod()"); textEditor.LastCompletionItemList.Complete(context, item); Assert.AreEqual(Normalize( programStart + "public override void AbstractMethod()\n" + " {\n" + " throw new NotImplementedException();\n" + " }" + programEnd), Normalize(textEditor.Document.Text) ); }
public void Complete(CompletionContext context) { if (context.Editor != this.textEditor) throw new ArgumentException("wrong editor"); CodeCompletionDataUsageCache.IncrementUsage("snippet" + codeSnippet.Name); using (context.Editor.Document.OpenUndoGroup()) { if (context.CompletionChar == '\t' || AlwaysInsertSnippet) { codeSnippet.TrackUsage("SnippetCompletionItem"); context.Editor.Document.Remove(context.StartOffset, context.Length); CreateSnippet().Insert(textArea); } else { context.Editor.Document.Replace(context.StartOffset, context.Length, this.Text); } } }
public void Complete(CompletionContext context) { ITextEditor editor = context.Editor; ClassFinder classFinder = new ClassFinder(ParserService.GetParseInformation(editor.FileName), editor.Caret.Line, editor.Caret.Column); int caretPosition = editor.Caret.Offset; IDocumentLine line = editor.Document.GetLine(editor.Caret.Line); string lineText = editor.Document.GetText(line.Offset, caretPosition - line.Offset); foreach (char c in lineText) { if (!char.IsWhiteSpace(c) && !char.IsLetterOrDigit(c)) { editor.Document.Replace(context.StartOffset, context.Length, this.Text); context.EndOffset = context.StartOffset + this.Text.Length; return; } } string indentation = lineText.Substring(0, lineText.Length - lineText.TrimStart().Length); editor.Document.Remove(line.Offset, caretPosition - line.Offset); foreach (ICompletionItemHandler handler in handlers) { if (handler.Handles(this)) { editor.Document.Insert(line.Offset, indentation); handler.Insert(context, this); return; } } CodeGenerator codeGen = ParserService.CurrentProjectContent.Language.CodeGenerator; string text = codeGen.GenerateCode(codeGen.GetOverridingMethod(member, classFinder), indentation); text = text.TrimEnd(); // remove newline from end editor.Document.Insert(line.Offset, text); int endPos = line.Offset + text.Length; line = editor.Document.GetLineForOffset(endPos); editor.JumpTo(line.LineNumber, endPos - line.Offset + 1); }
protected void TestTextInsert(string fileHeader, string fileFooter, char completionChar, ICompletionItemList list, ICompletionItem item, string expectedOutput, int expectedOffset) { this.textEditor.Document.Text = fileHeader + fileFooter; this.textEditor.Caret.Offset = fileHeader.Length; this.textEditor.CreateParseInformation(); CompletionContext context = new CompletionContext() { Editor = this.textEditor, CompletionChar = completionChar, StartOffset = textEditor.Caret.Offset, EndOffset = textEditor.Caret.Offset }; list.Complete(context, item); if (!context.CompletionCharHandled && context.CompletionChar != '\n') this.textEditor.Document.Insert(this.textEditor.Caret.Offset, completionChar + ""); string insertedText = this.textEditor.Document.GetText(fileHeader.Length, this.textEditor.Document.TextLength - fileHeader.Length - fileFooter.Length); Assert.AreEqual(expectedOutput, insertedText); Assert.AreEqual(fileHeader.Length + expectedOffset, textEditor.Caret.Offset); }
/// <inheritdoc/> public virtual void Complete(CompletionContext context, ICompletionItem item) { if (context == null) throw new ArgumentNullException("context"); if (item == null) throw new ArgumentNullException("item"); if (InsertSpace) { InsertSpace = false; context.Editor.Document.Insert(context.StartOffset, " "); context.StartOffset++; context.EndOffset++; } item.Complete(context); }
public void OverrideVirtualEvent() { CompletionContext context = new CompletionContext(); context.Editor = textEditor; context.StartOffset = textEditor.Caret.Offset; context.EndOffset = textEditor.Caret.Offset; ICompletionItem item = textEditor.LastCompletionItemList.Items.First(i=>i.Text == "VirtualEvent"); textEditor.LastCompletionItemList.Complete(context, item); Assert.AreEqual(Normalize( programStart + "public override event EventHandler VirtualEvent;" + programEnd), Normalize(textEditor.Document.Text) ); }
public void OverrideProtectedWriteProperty() { CompletionContext context = new CompletionContext(); context.Editor = textEditor; context.StartOffset = textEditor.Caret.Offset; context.EndOffset = textEditor.Caret.Offset; ICompletionItem item = textEditor.LastCompletionItemList.Items.First(i=>i.Text == "ProtectedWriteProperty"); textEditor.LastCompletionItemList.Complete(context, item); Assert.AreEqual(Normalize( programStart + "public override int ProtectedWriteProperty {\n" + " get {\n" + " return base.ProtectedWriteProperty;\n" + " }\n" + " protected set {\n" + " base.ProtectedWriteProperty = value;\n" + " }\n" + " }" + programEnd), Normalize(textEditor.Document.Text) ); }
ResolveResult ResolveAtCurrentOffset(string className, CompletionContext context) { if (context.Editor.FileName == null) return null; var document = context.Editor.Document; var position = document.OffsetToPosition(context.StartOffset); return ParserService.Resolve(new ExpressionResult(className), position.Line, position.Column, context.Editor.FileName, document.Text); }
/// <summary> /// Returns true if user is typing "Namespace.(*expr*)" /// </summary> bool IsUserTypingFullyQualifiedName(CompletionContext context) { return (context.StartOffset > 0) && (context.Editor.Document.GetCharAt(context.StartOffset - 1) == '.'); }
public virtual void Complete(CompletionContext context) { MarkAsUsed(); string insertedText = this.Text; IClass selectedClass = GetClassOrExtensionMethodClass(this.Entity); if (selectedClass != null) { // Class or Extension method is being inserted var editor = context.Editor; var document = context.Editor.Document; // Resolve should return AmbiguousResolveResult or something like that when we resolve a name that exists in more imported namespaces // - so that we would know that we always want to insert fully qualified name var nameResult = ResolveAtCurrentOffset(selectedClass.Name, context); bool addUsing = false; if (this.Entity is IClass) { if (!IsUserTypingFullyQualifiedName(context)) { nameResult = ResolveAtCurrentOffset(insertedText, context); addUsing = (!IsKnownName(nameResult)); } // Special case for Attributes if (insertedText.EndsWith("Attribute") && IsInAttributeContext(editor, context.StartOffset)) { insertedText = insertedText.RemoveFromEnd("Attribute"); } } else if (this.Entity is IMethod) { addUsing = !IsKnownName(nameResult); } context.Editor.Document.Replace(context.StartOffset, context.Length, insertedText); context.EndOffset = context.StartOffset + insertedText.Length; if (addUsing && nameResult != null && nameResult.CallingClass != null) { var cu = nameResult.CallingClass.CompilationUnit; NamespaceRefactoringService.AddUsingDeclaration(cu, document, selectedClass.Namespace, false); ParserService.BeginParse(editor.FileName, document); } } else { // Something else than a class or Extension method is being inserted - just insert text context.Editor.Document.Replace(context.StartOffset, context.Length, insertedText); context.EndOffset = context.StartOffset + insertedText.Length; } }
public virtual void Complete(CompletionContext context) { context.Editor.Document.Replace(context.StartOffset, context.Length, this.Text); // In case someone calls base.Complete() and then continues using the context, update EndOffset: context.EndOffset = context.StartOffset + this.Text.Length; }
public virtual void Complete(CompletionContext context) { context.Editor.Document.Replace(context.StartOffset, context.Length, this.Text); context.EndOffset = context.StartOffset + this.Text.Length; }
void ICompletionItem.Complete(CompletionContext context) { contextPassedToCompleteMethod = context; }
public virtual void Complete(CompletionContext context) { context.Editor.Document.Replace(context.StartOffset, context.Length, this.Text); // In case someone calls base.Complete() and then continues using the context, update EndOffset: context.EndOffset = context.StartOffset + this.Text.Length; }
/// <summary> /// Returns true if user is typing "Namespace.(*expr*)" /// </summary> bool IsUserTypingFullyQualifiedName(CompletionContext context) { return((context.StartOffset > 0) && (context.Editor.Document.GetCharAt(context.StartOffset - 1) == '.')); }
public void Complete(CompletionContext context) { snippet.Complete(context); }
public override void Complete(CompletionContext context) { CodeCompletionDataUsageCache.IncrementUsage("keyword." + this.Text); base.Complete(context); }
public void Complete(TextArea textArea, ISegment completionSegment, EventArgs insertionRequestEventArgs) { CompletionContext context = new CompletionContext { Editor = window.Editor, StartOffset = window.StartOffset, EndOffset = window.EndOffset }; TextCompositionEventArgs txea = insertionRequestEventArgs as TextCompositionEventArgs; KeyEventArgs kea = insertionRequestEventArgs as KeyEventArgs; if (txea != null && txea.Text.Length > 0) context.CompletionChar = txea.Text[0]; else if (kea != null && kea.Key == Key.Tab) context.CompletionChar = '\t'; window.ItemList.Complete(context, item); if (context.CompletionCharHandled && txea != null) txea.Handled = true; }
public override void Complete(CompletionContext context, ICompletionItem item) { using (context.Editor.Document.OpenUndoGroup()) { base.Complete(context, item); XamlCompletionContext xamlContext = XamlContextResolver.ResolveCompletionContext(context.Editor, context.CompletionChar); if (xamlContext.Description == XamlContextDescription.None && (context.StartOffset <= 0 || context.Editor.Document.GetCharAt(context.StartOffset - 1) != '<')) { context.Editor.Document.Insert(context.StartOffset, "<"); context.EndOffset++; } if (item is XamlCompletionItem && !item.Text.EndsWith(":", StringComparison.Ordinal)) { XamlCompletionItem cItem = item as XamlCompletionItem; if (xamlContext.Description == XamlContextDescription.InTag) { context.Editor.Document.Insert(context.EndOffset, "=\"\""); context.CompletionCharHandled = context.CompletionChar == '='; context.Editor.Caret.Offset--; new XamlCodeCompletionBinding().CtrlSpace(context.Editor); } else if (xamlContext.Description == XamlContextDescription.InMarkupExtension && !string.IsNullOrEmpty(xamlContext.RawAttributeValue)) { string valuePart = xamlContext.RawAttributeValue.Substring(0, xamlContext.ValueStartOffset); AttributeValue value = MarkupExtensionParser.ParseValue(valuePart); if (value != null && !value.IsString) { var markup = Utils.GetMarkupExtensionAtPosition(value.ExtensionValue, context.Editor.Caret.Offset); if (markup.NamedArguments.Count > 0 || markup.PositionalArguments.Count > 0) { int oldOffset = context.Editor.Caret.Offset; context.Editor.Caret.Offset = context.StartOffset; string word = context.Editor.GetWordBeforeCaret().TrimEnd(); int spaces = CountWhiteSpacesAtEnd(context.Editor.GetWordBeforeCaret()); int typeNameStart = markup.ExtensionType.IndexOf(':') + 1; if (!(word == "." || word == "," || word == ":") && markup.ExtensionType.Substring(typeNameStart, markup.ExtensionType.Length - typeNameStart) != word) { context.Editor.Document.Replace(context.Editor.Caret.Offset - spaces, spaces, ", "); oldOffset += (2 - spaces); } context.Editor.Caret.Offset = oldOffset; } } if (cItem.Text.EndsWith("=", StringComparison.OrdinalIgnoreCase)) new XamlCodeCompletionBinding().CtrlSpace(context.Editor); } } if (item is NewEventCompletionItem) { CreateEventHandlerCode(xamlContext, item as NewEventCompletionItem); } if (item is XmlnsCompletionItem) { context.Editor.Caret.Offset++; } switch (item.Text) { case "![CDATA[": context.Editor.Document.Insert(context.Editor.Caret.Offset, "]]>"); context.Editor.Caret.Offset -= 3; break; case "?": context.Editor.Document.Insert(context.Editor.Caret.Offset, "?>"); context.Editor.Caret.Offset -= 2; break; case "!--": context.Editor.Document.Insert(context.Editor.Caret.Offset, " -->"); context.Editor.Caret.Offset -= 4; break; } if (item.Text.StartsWith("/", StringComparison.OrdinalIgnoreCase)) { context.Editor.Document.Insert(context.EndOffset, ">"); context.CompletionCharHandled = context.CompletionChar == '>'; context.Editor.Caret.Offset++; } } }
public override void Complete(CompletionContext context) { if (declarationBegin > context.StartOffset) { base.Complete(context); return; } TypeSystemAstBuilder b = new TypeSystemAstBuilder(contextAtCaret); b.ShowTypeParameterConstraints = false; b.GenerateBody = true; var entityDeclaration = b.ConvertEntity(this.Entity); entityDeclaration.Modifiers &= ~(Modifiers.Virtual | Modifiers.Abstract); entityDeclaration.Modifiers |= Modifiers.Override; var body = entityDeclaration.GetChildByRole(Roles.Body); Statement baseCallStatement = body.Children.OfType<Statement>().FirstOrDefault(); if (!this.Entity.IsAbstract) { // modify body to call the base method if (this.Entity.SymbolKind == SymbolKind.Method) { var baseCall = new BaseReferenceExpression().Invoke(this.Entity.Name, new Expression[] { }); if (((IMethod)this.Entity).ReturnType.IsKnownType(KnownTypeCode.Void)) baseCallStatement = new ExpressionStatement(baseCall); else baseCallStatement = new ReturnStatement(baseCall); // Clear body of inserted method entityDeclaration.GetChildByRole(Roles.Body).Statements.Clear(); } } var document = context.Editor.Document; StringWriter w = new StringWriter(); var formattingOptions = FormattingOptionsFactory.CreateSharpDevelop(); var segmentDict = SegmentTrackingOutputFormatter.WriteNode(w, entityDeclaration, formattingOptions, context.Editor.Options); using (document.OpenUndoGroup()) { InsertionContext insertionContext = new InsertionContext(context.Editor.GetService(typeof(TextArea)) as TextArea, declarationBegin); insertionContext.InsertionPosition = context.Editor.Caret.Offset; string newText = w.ToString().TrimEnd(); document.Replace(declarationBegin, context.EndOffset - declarationBegin, newText); var throwStatement = entityDeclaration.Descendants.FirstOrDefault(n => n is ThrowStatement); if (throwStatement != null) { var segment = segmentDict[throwStatement]; context.Editor.Select(declarationBegin + segment.Offset, segment.Length); } CSharpFormatterHelper.Format(context.Editor, declarationBegin, newText.Length, formattingOptions); var refactoringContext = SDRefactoringContext.Create(context.Editor, CancellationToken.None); var typeResolveContext = refactoringContext.GetTypeResolveContext(); if (typeResolveContext == null) { return; } var resolvedCurrent = typeResolveContext.CurrentTypeDefinition; var entities = FindFieldsAndProperties(resolvedCurrent).ToList(); if (entities.Any()) { IEditorUIService uiService = context.Editor.GetService(typeof(IEditorUIService)) as IEditorUIService; ITextAnchor endAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); endAnchor.MovementType = AnchorMovementType.AfterInsertion; ITextAnchor startAnchor = context.Editor.Document.CreateAnchor(context.Editor.Caret.Offset); startAnchor.MovementType = AnchorMovementType.BeforeInsertion; ITextAnchor insertionPos = context.Editor.Document.CreateAnchor(endAnchor.Offset); insertionPos.MovementType = AnchorMovementType.BeforeInsertion; AbstractInlineRefactorDialog dialog = new OverrideToStringMethodDialog(insertionContext, context.Editor, insertionPos, entities, baseCallStatement); dialog.Element = uiService.CreateInlineUIElement(insertionPos, dialog); insertionContext.RegisterActiveElement(new InlineRefactorSnippetElement(cxt => null, ""), dialog); } else { if (baseCallStatement != null) { // Add default base call MethodDeclaration insertedOverrideMethod = refactoringContext.GetNode().PrevSibling as MethodDeclaration; if (insertedOverrideMethod == null) { // We are not inside of a method declaration return; } using (Script script = refactoringContext.StartScript()) { script.AddTo(insertedOverrideMethod.Body, baseCallStatement); } } } insertionContext.RaiseInsertionCompleted(EventArgs.Empty); } }
public override void Complete(CompletionContext context) { CodeCompletionDataUsageCache.IncrementUsage("keyword." + this.Text); base.Complete(context); }