/// <summary>
 /// These appear to represent members of classes
 /// </summary>
 /// <param name="entity"></param>
 /// <returns></returns>
 public ICompletionData CreateEntityCompletionData(ICSharpCode.NRefactory.TypeSystem.IEntity entity)
 {
     var cd = new EntityCompletionData(entity);
     return cd;
 }
Exemplo n.º 2
0
        static void ProcessEventCompletion(string code, int position, ICompletionData data, List <ICompletionData> result)
        {
            try
            {
                var lineStart = code.Substring(0, position).LastIndexOf('\n');
                if (lineStart == -1)
                {
                    lineStart = 0;
                }

                var    leftPart = code.Substring(lineStart, position - lineStart).TrimEnd(); //line left part
                string indent   = new string(' ', leftPart.Length);

                string eventName = data.DisplayText;

                // lambda event handler
                data.DisplayText = "On" + eventName + " - lambda";
                string handlerArgs = string.Join(", ", data.InvokeParameters.Select(p => p.Split(' ').LastOrDefault()).ToArray());

                var sb = new StringBuilder()
                         .AppendLine("(" + handlerArgs + ")=>")
                         .AppendLine(indent + "{")
                         .AppendLine(indent + "   $|$")
                         .AppendLine(indent + "};");

                data.CompletionText = sb.ToString();

                var root = CSharpSyntaxTree.ParseText(code)
                           .GetRoot();

                string[] namespaces = root.GetUsingNamespace(code);

                // delegate event handler
                handlerArgs = string.Join(", ", data.InvokeParameters.Select(x => x.ShrinkNamespaces(namespaces)).ToArray());

                sb.Clear()
                .AppendLine("delegate(" + handlerArgs + ")")
                .AppendLine(indent + "{")
                .AppendLine(indent + "   $|$")
                .AppendLine(indent + "};");

                //add delegate version of the same event handler
                var delegateCompletion = new EntityCompletionData().CopyPropertiesFrom(data);
                delegateCompletion.CompletionText = sb.ToString();
                delegateCompletion.DisplayText    = "On" + eventName + " - delegate";

                result.Add(delegateCompletion);

                // method event handler
                string handlerName = "On" + eventName;

                var nodes = root.DescendantNodes();

                var methodAtCursor = nodes.Where(x => x.Kind() == SyntaxKind.MethodDeclaration &&
                                                 x.FullSpan.End >= position)
                                     .OfType <MethodDeclarationSyntax>()
                                     .Select(x => new
                {
                    End      = x.FullSpan.End,
                    Distance = x.FullSpan.End - position,
                    Data     = x,
                })
                                     .OrderBy(x => x.Distance)
                                     .FirstOrDefault();

                if (methodAtCursor != null)
                {
                    indent = new string(' ', methodAtCursor.Data.Span.Start - methodAtCursor.Data.FullSpan.Start);

                    var similarMethods = nodes.OfType <MethodDeclarationSyntax>()
                                         .Where(x => x.Parent == methodAtCursor.Data.Parent &&
                                                x.Identifier.Text.StartsWith(handlerName));
                    if (similarMethods.Any())
                    {
                        handlerName = handlerName + (similarMethods.Count() + 1);
                    }

                    var modifier = methodAtCursor.Data
                                   .Modifiers
                                   .Where(x => x.Text == "static")
                                   .Select(x => "static ")
                                   .FirstOrDefault();

                    //add delegate version of the same event handler
                    var methodCompletion = new EntityCompletionData().CopyPropertiesFrom(data);
                    methodCompletion.CompletionText = handlerName + ";";
                    methodCompletion.DisplayText    = "On" + eventName + " - method";

                    var returnType = delegateCompletion.InvokeReturn.ShrinkNamespaces(namespaces) + " ";

                    sb.Clear()
                    .AppendLine()
                    .AppendLine(indent + modifier + returnType + handlerName + "(" + handlerArgs + ")")
                    .AppendLine(indent + "{")
                    .AppendLine(indent + "    $|$")
                    .AppendLine(indent + "}");

                    methodCompletion.Tag = new Dictionary <string, object>()
                    {
                        { "insertionPos", methodAtCursor.End },
                        { "insertionContent", sb.ToString() },
                    };

                    result.Add(methodCompletion);
                }
            }
            catch { }
        }
        /// <summary>
        /// These appear to represent members of classes
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public ICompletionData CreateEntityCompletionData(ICSharpCode.NRefactory.TypeSystem.IEntity entity)
        {
            var cd = new EntityCompletionData(entity);

            return(cd);
        }