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 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 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);
        }
Beispiel #4
0
        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);
        }
        public HotspotItems GetLookupItems(IHotspotContext context, IList <string> arguments)
        {
            if (context.SessionContext.TextControl == null)
            {
                return(null);
            }

            var container = TextControlToPsi.GetContainingTypeOrTypeMember(
                context.SessionContext.Solution,
                context.SessionContext.TextControl);

            if (!(container is IMethod))
            {
                return(null);
            }
            var method = (IMethod)container;

            var lookupItems = new List <ILookupItem>();

            lookupItems.AddRange(method.Parameters.Select(param => new TextLookupItem(param.ShortName)));

            return(new HotspotItems(lookupItems));
        }