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);
}
