void ShowCompletionData(ICompletionData[] dataList, string text) { string lowerText = text.ToLowerInvariant(); foreach (ICompletionData data in dataList) { CodeCompletionData ccd = data as CodeCompletionData; if (ccd == null) { return; } string dataText = ccd.Text; if (dataText.Length >= text.Length) { if (dataText.ToLowerInvariant().IndexOf(lowerText) >= 0) { if (ccd.Class != null) { AddItem(ccd.Class, data.ImageIndex, data.Priority); } else if (ccd.Member != null) { AddItem(ccd.Member, data.ImageIndex, data.Priority); } } } } }
void ShowCompletionData(ICompletionData[] dataList, string text) { string lowerText = text.ToLowerInvariant(); foreach (ICompletionData data in dataList) { CodeCompletionData ccd = data as CodeCompletionData; if (ccd == null) { return; } string dataText = ccd.Text; int matchType = GetMatchType(text, dataText); if (matchType >= 0) { if (ccd.Class != null) { AddItem(ccd.Class, data.ImageIndex, data.Priority, matchType); } else if (ccd.Member != null) { AddItem(ccd.Member, data.ImageIndex, data.Priority, matchType); } } } }
public async Task <List <CodeCompletionData> > CodeCompleteAtAsync(ISourceFile sourceFile, int line, int column, List <UnsavedFile> unsavedFiles, string filter) { var result = new List <CodeCompletionData>(); var dataAssociation = GetAssociatedData(sourceFile); var response = await dataAssociation.Solution.Server.AutoComplete(sourceFile.FilePath, unsavedFiles.FirstOrDefault()?.Contents, line, column); if (response != null) { foreach (var completion in response) { var newCompletion = new CodeCompletionData() { Suggestion = completion.CompletionText, Priority = 1, Hint = completion.DisplayText, BriefComment = completion.Description?.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault(), Kind = FromOmniSharpKind(completion.Kind) }; if (filter == string.Empty || completion.CompletionText.StartsWith(filter)) { result.Add(newCompletion); } } } return(result); }
void CodeCompletionListViewSelectedItemChanged(object sender, EventArgs e) { if (codeCompletionListView != null) { ICompletionData data = codeCompletionListView.SelectedCompletionData; if (showDeclarationWindow && data != null && data.Description != null && data.Description.Length > 0) { declarationViewWindow.Description = data.Description; if (data is O2.External.SharpDevelop.Ascx.CodeCompletionData) { lastCodeCompleteData = (O2.External.SharpDevelop.Ascx.CodeCompletionData)data; if (lastCodeCompleteData.member.notNull()) { var memberSignature = lastCodeCompleteData.member.str().remove("[DefaultMethod: ").removeLastChar(); declarationViewWindow.Description = (declarationViewWindow.Description + memberSignature).trim(); } if (lastCodeCompleteData.c.notNull()) { var classDescription = lastCodeCompleteData.c.str().remove("[DefaultClass: ").removeLastChar().line(); foreach (var method in lastCodeCompleteData.c.Methods) { classDescription += " - {0}".info(method.str()).line(); } declarationViewWindow.Description = (declarationViewWindow.Description + classDescription).trim(); } } SetDeclarationViewLocation(); } else { declarationViewWindow.Description = null; } } }
public override bool InsertAction(ICompletionData data, ICSharpCode.TextEditor.TextArea textArea, int insertionOffset, char key) { CodeCompletionData ccData = data as CodeCompletionData; if (IsAttributeCompletion && ccData != null) { textArea.Caret.Position = textArea.Document.OffsetToPosition(insertionOffset); textArea.InsertString(ccData.Text + "=\"\""); textArea.Caret.Column -= 1; SharpDevelopTextAreaControl editor = textArea.MotherTextEditorControl as SharpDevelopTextAreaControl; if (editor != null) { WorkbenchSingleton.SafeThreadAsyncCall( delegate { XamlCompletionDataProvider provider = new XamlCompletionDataProvider(); provider.AllowCompleteExistingExpression = true; editor.ShowCompletionWindow(provider, '\0'); } ); } return(false); } else { return(base.InsertAction(data, textArea, insertionOffset, key)); } }
/// <summary> /// Triggers the authentication flow /// </summary> /// <remarks> /// This returns a boolean to remain compatible with our native /// implementation - however it always returns true in managed code /// </remarks> /// <returns><c>true</c></returns> public bool Authenticate() { this.client.GetAsync(this.codeUri).ContinueWith(async(Task <HttpResponseMessage> prev) => { var message = prev.Result; var eventData = new CodeCompletionData() { http_status = (int)message.StatusCode }; if (message.StatusCode == HttpStatusCode.OK) { var body = await message.Content.ReadAsStringAsync(); var obj = JObject.Parse(body); eventData.device_code = obj.Value <string>("device_code"); eventData.user_code = obj.Value <string>("user_code"); eventData.interval = obj.Value <int>("interval"); eventData.verification_url = obj.Value <string>("verification_url"); // schedule our polling logic this.pollTimer = new Timer(PollTimer, eventData.device_code, TimeSpan.FromMilliseconds(0), TimeSpan.FromSeconds(eventData.interval)); } this.CodeComplete?.Invoke(eventData); }); // this maintains api compatibility with our native version // but is technically useless here (since it's always true) return(true); }
protected bool ProvideContextCompletion(CodeEditorControl editor, IReturnType expected, char charTyped) { if (expected == null) { return(false); } IClass c = expected.GetUnderlyingClass(); if (c == null) { return(false); } if (c.ClassType == ClassType.Enum) { CtrlSpaceCompletionDataProvider cdp = new CtrlSpaceCompletionDataProvider(); cdp.ForceNewExpression = true; ContextCompletionDataProvider cache = new ContextCompletionDataProvider(cdp); cache.activationKey = charTyped; cache.GenerateCompletionData(editor.ActiveViewControl.FileName, editor.ActiveViewControl, charTyped); ICompletionData[] completionData = cache.CompletionData; Array.Sort(completionData); for (int i = 0; i < completionData.Length; i++) { CodeCompletionData ccd = completionData[i] as CodeCompletionData; if (ccd != null && ccd.Class != null) { if (ccd.Class.FullyQualifiedName == expected.FullyQualifiedName) { cache.DefaultIndex = i; break; } } } if (cache.DefaultIndex >= 0) { if (charTyped != ' ') { cdp.InsertSpace = true; } editor.ActiveViewControl.ShowCompletionWindow(cache, charTyped); return(true); } } return(false); }
private async Task <List <CodeCompletionData> > CodeCompleteAtAsync(IEditor editor, int index, List <UnsavedFile> unsavedFiles, string filter = "") { var currentUnsavedFile = unsavedFiles.FirstOrDefault(f => f.FileName == editor.SourceFile.FilePath); var currentFileConts = currentUnsavedFile?.Contents ?? File.ReadAllText(editor.SourceFile.FilePath); var caretPosition = index; var completions = await _typeScriptContext.GetCompletionsAtPositionAsync(editor.SourceFile.FilePath, caretPosition); var editorCompletions = completions.Entries.Select(cc => { var ccData = new CodeCompletionData(cc.Name, cc.Name) { Kind = ConvertCodeCompletionKind(cc.Kind), BriefComment = cc.Name }; return(ccData); }) .ToList(); return(editorCompletions); }
public FieldCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public EnumConstantCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public KeywordCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public PropertyCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public ClassCompletionDataViewModel(CodeCompletionData model) : base(model) { }
/// <summary> /// Generates the completion data. This method is called by the text editor control. /// </summary> public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped) { List <ICompletionData> completionData = new List <ICompletionData>(); // delegate { } completionData.Add(new DelegateCompletionData("delegate { };", 3, "${res:CSharpBinding.InsertAnonymousMethod}")); CSharpAmbience ambience = new CSharpAmbience(); // get eventHandler type name incl. type argument list ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList | ConversionFlags.UseFullyQualifiedTypeNames; string eventHandlerFullyQualifiedTypeName = ambience.Convert(resolvedReturnType); ambience.ConversionFlags = ConversionFlags.ShowParameterNames | ConversionFlags.ShowTypeParameterList; string eventHandlerTypeName = ambience.Convert(resolvedReturnType); // retrieve Invoke method from resolvedReturnType instead of resolvedClass to get a method where // type arguments are substituted. IMethod invoke = resolvedReturnType.GetMethods().Find(delegate(IMethod m) { return(m.Name == "Invoke"); }); StringBuilder parameterString = new StringBuilder(); if (invoke != null) { // build the parameter string for (int i = 0; i < invoke.Parameters.Count; ++i) { if (i > 0) { parameterString.Append(", "); } parameterString.Append(ambience.Convert(invoke.Parameters[i])); } // delegate(object sender, EventArgs e) { }; StringBuilder anonMethodWithParametersBuilder = new StringBuilder("delegate(").Append(parameterString.ToString()).Append(") { };"); completionData.Add(new DelegateCompletionData(anonMethodWithParametersBuilder.ToString(), 3, "${res:CSharpBinding.InsertAnonymousMethodWithParameters}")); // new EventHandler(ClassName_EventName); IClass callingClass = resolveResult.CallingClass; bool inStatic = false; if (resolveResult.CallingMember != null) { inStatic = resolveResult.CallingMember.IsStatic; } // ...build the new handler name... string newHandlerName = BuildHandlerName(); if (newHandlerName == null) { MemberResolveResult mrr = resolveResult as MemberResolveResult; IEvent eventMember = (mrr != null ? mrr.ResolvedMember as IEvent : null); newHandlerName = ((callingClass != null) ? callingClass.Name : "callingClass") + "_" + ((eventMember != null) ? eventMember.Name : "eventMember"); } // ...build the completion text... StringBuilder newHandlerTextBuilder = new StringBuilder("new ").Append(eventHandlerTypeName).Append("("); newHandlerTextBuilder.Append(newHandlerName).Append(");"); // ...build the optional new method text... StringBuilder newHandlerCodeBuilder = new StringBuilder(); newHandlerCodeBuilder.AppendLine().AppendLine(); if (inStatic) { newHandlerCodeBuilder.Append("static "); } newHandlerCodeBuilder.Append(ambience.Convert(invoke.ReturnType)).Append(" ").Append(newHandlerName); newHandlerCodeBuilder.Append("(").Append(parameterString.ToString()).AppendLine(")"); newHandlerCodeBuilder.AppendLine("{"); newHandlerCodeBuilder.AppendLine("throw new NotImplementedException();"); newHandlerCodeBuilder.Append("}"); // ...and add it to the completionData. completionData.Add(new NewEventHandlerCompletionData( newHandlerTextBuilder.ToString(), 2 + newHandlerName.Length, newHandlerName.Length, "new " + eventHandlerFullyQualifiedTypeName + "(" + newHandlerName + StringParser.Parse(")\n${res:CSharpBinding.GenerateNewHandlerInstructions}\n") + CodeCompletionData.ConvertDocumentation(resolvedClass.Documentation), resolveResult, newHandlerCodeBuilder.ToString() )); if (callingClass != null) { foreach (IMethod method in callingClass.DefaultReturnType.GetMethods()) { if (inStatic && !method.IsStatic) { continue; } if (!method.IsAccessible(callingClass, true)) { continue; } if (method.Parameters.Count != invoke.Parameters.Count) { continue; } // check return type compatibility: if (!MemberLookupHelper.ConversionExists(method.ReturnType, invoke.ReturnType)) { continue; } bool ok = true; for (int i = 0; i < invoke.Parameters.Count; i++) { if (!MemberLookupHelper.ConversionExists(invoke.Parameters[i].ReturnType, method.Parameters[i].ReturnType)) { ok = false; break; } } if (ok) { completionData.Add(new CodeCompletionData(method)); } } } } return(completionData.ToArray()); }
public MethodCompletionDataViewModel(CodeCompletionData model) : base(model) { }
void AddCompletionData(List<ICompletionData> resultList, ArrayList completionData) { // var currentCodeCompleteText = ""; // var lenght = textEditor.currentOffset() - startOffset; // if (lenght >0) // currentCodeCompleteText = textEditor.get_Text(startOffset,lenght); // "{0}:{1} = {2}".format(startOffset,lenght , currentCodeCompleteText).debug(); // used to store the method names for grouping overloads Dictionary<string, CodeCompletionData> nameDictionary = new Dictionary<string, CodeCompletionData>(); // Add the completion data as returned by SharpDevelop.Dom to the // list for the text editor foreach (object obj in completionData) { if (obj is string) { // namespace names are returned as string resultList.Add(new DefaultCompletionData((string)obj, "namespace " + obj, 5)); } else if (obj is IClass) { IClass c = (IClass)obj; resultList.Add(new CodeCompletionData(c,this)); } else if (obj is IMember) { IMember m = (IMember)obj; if (m is IMethod && ((m as IMethod).IsConstructor)) { // Skip constructors continue; } // if OnlyShowCodeCompleteResulstFromO2Namespace filter for only O2.* namepace if (OnlyShowCodeCompleteResulstFromO2Namespace && m.DeclaringType.Namespace.starts("O2") == false) continue; // NOT WORKING only show items that match currentCodeCompleteText regex // if (currentCodeCompleteText != "" && m.DotNetName.nregEx(currentCodeCompleteText)) // continue; //if // Group results by name and add "(x Overloads)" to the // description if there are multiple results with the same name. CodeCompletionData data; if (nameDictionary.TryGetValue(m.Name, out data)) { data.AddOverload(); } else { nameDictionary[m.Name] = data = new CodeCompletionData(m,this); resultList.Add(data); } } else { // Current ICSharpCode.SharpDevelop.Dom should never return anything else throw new NotSupportedException(); } } }
/// <summary> /// Generates the completion data. This method is called by the text editor control. /// </summary> public override ICompletionData[] GenerateCompletionData(string fileName, EditViewControl textArea, char charTyped) { string methodName = this.resolveResult.CallingClass.Name + "_" + this.expression.Trim().Substring(this.expression.Trim().LastIndexOf('.') + 1); List <ICompletionData> completionData = new List <ICompletionData>(); completionData.Add(new DelegateCompletionData("delegate { };", 3, "Insert Anonymous Method")); CSharpAmbience ambience = new CSharpAmbience(); ambience.ConversionFlags = ConversionFlags.ShowParameterNames; IMethod invoke = resolvedClass.SearchMember("Invoke", LanguageProperties.CSharp) as IMethod; DomRegion r = this.resolveResult.CallingMember.BodyRegion; DomRegion rm = this.resolveResult.CallingMember.Region; TextPoint cPos = textArea.Caret.Position; TextRange trIntened = new TextRange(0, rm.BeginLine - 1, rm.BeginColumn - 1, rm.BeginLine - 1); string IntendString = textArea.Document.GetRange(trIntened); int curPos = textArea.Document.PointToIntPos(new TextPoint(0, r.EndLine - 1)); StringBuilder parambuilder = new StringBuilder("("); if (invoke != null) { StringBuilder builder = new StringBuilder("delegate("); for (int i = 0; i < invoke.Parameters.Count; ++i) { if (i > 0) { builder.Append(", "); parambuilder.Append(", "); } builder.Append(ambience.Convert(invoke.Parameters[i])); parambuilder.Append(ambience.Convert(invoke.Parameters[i])); } builder.Append(") { };"); parambuilder.Append(")"); string MethodBody = "new " + resolveResult.ResolvedType.Name + "(delegate" + parambuilder + "{ });"; completionData.Add(new DelegateCompletionData(MethodBody, 4, "delegate " + resolvedClass.FullyQualifiedName + "\n" + CodeCompletionData.GetDocumentation(resolvedClass.Documentation))); completionData.Add(new DelegateCompletionData(builder.ToString(), 3, "Insert Anonymous Method With Parameters")); IClass callingClass = resolveResult.CallingClass; IClass eventReturnType = invoke.ReturnType.GetUnderlyingClass(); IClass[] eventParameters = new IClass[invoke.Parameters.Count]; for (int i = 0; i < eventParameters.Length; i++) { eventParameters[i] = invoke.Parameters[i].ReturnType.GetUnderlyingClass(); if (eventParameters[i] == null) { eventReturnType = null; break; } } if (callingClass != null && eventReturnType != null) { bool inStatic = false; if (resolveResult.CallingMember != null) { inStatic = resolveResult.CallingMember.IsStatic; } foreach (IMethod method in callingClass.DefaultReturnType.GetMethods()) { if (inStatic && !method.IsStatic) { continue; } if (!method.IsAccessible(callingClass, true)) { continue; } if (method.Parameters.Count != invoke.Parameters.Count) { continue; } // check return type compatibility: IClass c2 = method.ReturnType.GetUnderlyingClass(); if (c2 == null || !c2.IsTypeInInheritanceTree(eventReturnType)) { continue; } bool ok = true; for (int i = 0; i < eventParameters.Length; i++) { c2 = method.Parameters[i].ReturnType.GetUnderlyingClass(); if (c2 == null || !eventParameters[i].IsTypeInInheritanceTree(c2)) { ok = false; break; } } if (ok) { completionData.Add(new CodeCompletionData(method)); } } } } return(completionData.ToArray()); }
/// <summary> /// Generates the completion data. This method is called by the text editor control. /// </summary> public override ICompletionData[] GenerateCompletionData(string fileName, TextArea textArea, char charTyped) { List <ICompletionData> completionData = new List <ICompletionData>(); completionData.Add(new DelegateCompletionData("new " + resolveResult.ResolvedType.Name + "();", 2, "delegate " + resolvedClass.FullyQualifiedName + "\n" + CodeCompletionData.GetDocumentation(resolvedClass.Documentation))); completionData.Add(new DelegateCompletionData("delegate { };", 3, "${res:CSharpBinding.InsertAnonymousMethod}")); CSharpAmbience ambience = new CSharpAmbience(); ambience.ConversionFlags = ConversionFlags.ShowParameterNames; IMethod invoke = resolvedClass.SearchMember("Invoke", LanguageProperties.CSharp) as IMethod; if (invoke != null) { StringBuilder builder = new StringBuilder("delegate("); for (int i = 0; i < invoke.Parameters.Count; ++i) { if (i > 0) { builder.Append(", "); } builder.Append(ambience.Convert(invoke.Parameters[i])); } builder.Append(") { };"); completionData.Add(new DelegateCompletionData(builder.ToString(), 3, "${res:CSharpBinding.InsertAnonymousMethodWithParameters}")); IClass callingClass = resolveResult.CallingClass; IClass eventReturnType = invoke.ReturnType.GetUnderlyingClass(); IClass[] eventParameters = new IClass[invoke.Parameters.Count]; for (int i = 0; i < eventParameters.Length; i++) { eventParameters[i] = invoke.Parameters[i].ReturnType.GetUnderlyingClass(); if (eventParameters[i] == null) { eventReturnType = null; break; } } if (callingClass != null && eventReturnType != null) { bool inStatic = false; if (resolveResult.CallingMember != null) { inStatic = resolveResult.CallingMember.IsStatic; } foreach (IMethod method in callingClass.DefaultReturnType.GetMethods()) { if (inStatic && !method.IsStatic) { continue; } if (!method.IsAccessible(callingClass, true)) { continue; } if (method.Parameters.Count != invoke.Parameters.Count) { continue; } // check return type compatibility: IClass c2 = method.ReturnType.GetUnderlyingClass(); if (c2 == null || !c2.IsTypeInInheritanceTree(eventReturnType)) { continue; } bool ok = true; for (int i = 0; i < eventParameters.Length; i++) { c2 = method.Parameters[i].ReturnType.GetUnderlyingClass(); if (c2 == null || !eventParameters[i].IsTypeInInheritanceTree(c2)) { ok = false; break; } } if (ok) { completionData.Add(new CodeCompletionData(method)); } } } } return(completionData.ToArray()); }
public ParameterCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public DefaultCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public async Task <CodeCompletionResults> CodeCompleteAtAsync(ISourceFile file, int index, int line, int column, List <UnsavedFile> unsavedFiles, char lastChar, string filter) { var clangUnsavedFiles = new List <ClangUnsavedFile>(); foreach (var unsavedFile in unsavedFiles) { clangUnsavedFiles.Add(new ClangUnsavedFile(unsavedFile.FileName, unsavedFile.Contents)); } var result = new CodeCompletionResults(); await clangAccessJobRunner.InvokeAsync(() => { var translationUnit = GetAndParseTranslationUnit(file, clangUnsavedFiles); if (translationUnit != null) { var completionResults = translationUnit.CodeCompleteAt(file.Location, line, column, clangUnsavedFiles.ToArray(), CodeCompleteFlags.IncludeBriefComments | CodeCompleteFlags.IncludeMacros | CodeCompleteFlags.IncludeCodePatterns); completionResults.Sort(); result.Contexts = (CompletionContext)completionResults.Contexts; if (result.Contexts == CompletionContext.Unexposed && lastChar == ':') { result.Contexts = CompletionContext.AnyType; // special case Class::<- here static class member access. } foreach (var codeCompletion in completionResults.Results) { var typedText = string.Empty; var hint = string.Empty; if (codeCompletion.CompletionString.Availability == AvailabilityKind.Available || codeCompletion.CompletionString.Availability == AvailabilityKind.Deprecated) { foreach (var chunk in codeCompletion.CompletionString.Chunks) { if (chunk.Kind == CompletionChunkKind.TypedText) { typedText = chunk.Text; } hint += chunk.Text; switch (chunk.Kind) { case CompletionChunkKind.LeftParen: case CompletionChunkKind.LeftAngle: case CompletionChunkKind.LeftBrace: case CompletionChunkKind.LeftBracket: case CompletionChunkKind.RightAngle: case CompletionChunkKind.RightBrace: case CompletionChunkKind.RightBracket: case CompletionChunkKind.RightParen: case CompletionChunkKind.Placeholder: case CompletionChunkKind.Comma: break; default: hint += " "; break; } } if (filter == string.Empty || typedText.StartsWith(filter)) { var completion = new CodeCompletionData { Suggestion = typedText, Priority = codeCompletion.CompletionString.Priority, Kind = FromClangKind(codeCompletion.CursorKind), Hint = hint, BriefComment = codeCompletion.CompletionString.BriefComment }; result.Completions.Add(completion); if (completion.Kind == CodeCompletionKind.OverloadCandidate) { Console.WriteLine("TODO Implement overload candidate."); } } } } completionResults.Dispose(); } }); return(result); }
void AddCompletionData(List<ICompletionData> resultList, ArrayList completionData) { // ReSharper disable CanBeReplacedWithTryCastAndCheckForNull // used to store the method names for grouping overloads var nameDictionary = new Dictionary<string, CodeCompletionData>(); // Add the completion data as returned by SharpDevelop.Dom to the // list for the text editor foreach (object obj in completionData) { if (obj is string) { // namespace names are returned as string resultList.Add(new DefaultCompletionData((string)obj, "namespace " + obj, 5)); } else if (obj is IClass) { var c = (IClass)obj; resultList.Add(new CodeCompletionData(c,this)); } else if (obj is IMember) { var m = (IMember)obj; if (m is IMethod && ((m as IMethod).IsConstructor)) { // Skip constructors continue; } // if OnlyShowCodeCompleteResulstFromO2Namespace filter for only FluentSharp.* namepace if (OnlyShowCodeCompleteResultsFromO2Namespace && m.DeclaringType.Namespace.starts("FluentSharp") == false) continue; // NOT WORKING only show items that match currentCodeCompleteText regex // if (currentCodeCompleteText != "" && m.DotNetName.nregEx(currentCodeCompleteText)) // continue; //if // Group results by name and add "(x Overloads)" to the // description if there are multiple results with the same name. CodeCompletionData data; if (nameDictionary.TryGetValue(m.Name, out data)) { data.AddOverload(m); } else { nameDictionary[m.Name] = data = new CodeCompletionData(m,this); resultList.Add(data); } } else { // Current ICSharpCode.SharpDevelop.Dom should never return anything else throw new NotSupportedException(); } } // ReSharper restore CanBeReplacedWithTryCastAndCheckForNull }
public async Task <CodeCompletionResults> CodeCompleteAtAsync(int index, int line, int column, IEnumerable <UnsavedFile> unsavedFiles, char previousChar, string filter) { if (_editor.SourceFile is MetaDataFile) { return(null); } var result = new CodeCompletionResults(); var dataAssociation = GetAssociatedData(_editor); var workspace = RoslynWorkspace.GetWorkspace(dataAssociation.Solution); var document = workspace.GetDocument(_editor.SourceFile); var semanticModel = await document.GetSemanticModelAsync(); var completionService = CompletionService.GetService(document); var data = await completionService.GetCompletionsAsync(document, index); if (data != null) { var recommendedSymbols = await Microsoft.CodeAnalysis.Recommendations.Recommender.GetRecommendedSymbolsAtPositionAsync(semanticModel, index, workspace); foreach (var completion in data.Items) { var insertionText = completion.DisplayText; if (completion.Properties.ContainsKey("InsertionText")) { insertionText = completion.Properties["InsertionText"]; } var selectionBehavior = Languages.CompletionItemSelectionBehavior.Default; int priority = 0; if (completion.Rules.SelectionBehavior != Microsoft.CodeAnalysis.Completion.CompletionItemSelectionBehavior.Default) { selectionBehavior = (Languages.CompletionItemSelectionBehavior)completion.Rules.SelectionBehavior; priority = completion.Rules.MatchPriority; } if (completion.Properties.ContainsKey("Provider") && completion.Properties["Provider"] == "Microsoft.CodeAnalysis.CSharp.Completion.Providers.SymbolCompletionProvider") { var symbols = recommendedSymbols.Where(x => x.Name == completion.Properties["SymbolName"] && (int)x.Kind == int.Parse(completion.Properties["SymbolKind"])).Distinct(); if (symbols != null && symbols.Any()) { foreach (var symbol in symbols) { if (symbol != null) { var newCompletion = new CodeCompletionData(symbol.Name, completion.FilterText, insertionText, null, selectionBehavior, priority); if (completion.Properties.ContainsKey("SymbolKind")) { newCompletion.Kind = FromOmniSharpKind(completion.Properties["SymbolKind"]); } var xmlDocumentation = symbol.GetDocumentationCommentXml(); if (xmlDocumentation != string.Empty) { var docComment = DocumentationComment.From(xmlDocumentation, Environment.NewLine); newCompletion.BriefComment = docComment.SummaryText; } result.Completions.Add(newCompletion); } } } } else { var newCompletion = new CodeCompletionData(completion.DisplayText, completion.FilterText, insertionText, null, selectionBehavior, priority); if (completion.Properties.ContainsKey("SymbolKind")) { newCompletion.Kind = FromOmniSharpKind(completion.Properties["SymbolKind"]); } result.Completions.Add(newCompletion); } } result.Contexts = Languages.CompletionContext.AnyType; } return(result); }
public MacroCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public VariableCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public StructCompletionDataViewModel(CodeCompletionData model) : base(model) { }
public SnippetCompletionDataViewModel(CodeCompletionData model) : base(model) { }