C# IDataContext.GetSelectedTreeNode方法代码示例

        public bool IsAvailable(IDataContext dataContext)
        {
            // todo make this resolvable also via the AllTypes... line
            var invokedNode = dataContext.GetSelectedTreeNode<IExpression>();

            return cachedRegistrations.Any(r => r.Registration.RegistrationElement.Children().Contains(invokedNode));
        }

        public RegisteredComponentsSearchRequest GetRegisteredComponentsRequest(IDataContext dataContext)
        {
            ISolution solution = dataContext.GetData(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
            if (solution == null)
            {
                throw new InvalidOperationException("Unable to get the solution");
            }

            var invokedNode = dataContext.GetSelectedTreeNode<IExpression>();

            IDocument document = dataContext.GetData(JetBrains.IDE.DataConstants.DOCUMENT);
            if (document == null)
                return null;

            IPsiSourceFile psiSourceFile = document.GetPsiSourceFile(solution);
            if (psiSourceFile == null)
            {
                return null;
            }

            var registration = solution.GetComponent<IPatternManager>().GetRegistrationsForFile(psiSourceFile)
                .FirstOrDefault(r => r.Registration.RegistrationElement.Children().Contains(invokedNode));
            if (registration == null)
            {
                return null;
            }

            return new RegisteredComponentsSearchRequest(solution, locks, registration.Registration);
        }

        public RegisteredComponentsSearchRequest GetRegisteredComponentsRequest(IDataContext dataContext)
        {
            ISolution solution = dataContext.GetData(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
            if (solution == null)
            {
                throw new InvalidOperationException("Unable to get the solution");
            }

            var invokedNode = dataContext.GetSelectedTreeNode<IExpression>();
            var registration = cachedRegistrations.FirstOrDefault(r => r.Registration.RegistrationElement.Children().Contains(invokedNode));
            if (registration == null)
            {
                return null;
            }

            return new RegisteredComponentsSearchRequest(solution, locks, registration.Registration);
        }

        public bool IsAvailable(IDataContext dataContext)
        {
            ISolution solution = dataContext.GetData(JetBrains.ProjectModel.DataContext.DataConstants.SOLUTION);
            if (solution == null)
                return false;
            #if SDK70
            IDocument document = dataContext.GetData(JetBrains.DocumentModel.DataConstants.DOCUMENT);
            #else
            IDocument document = dataContext.GetData(JetBrains.IDE.DataConstants.DOCUMENT);
            #endif

            if (document == null)
                return false;
            #if SDK70
            DocumentOffset documentOffset = dataContext.GetData(JetBrains.DocumentModel.DataConstants.DOCUMENT_OFFSET);
            #else
            DocumentOffset documentOffset = dataContext.GetData(JetBrains.IDE.DataConstants.DOCUMENT_OFFSET);
            #endif
            if (documentOffset == null)
                return false;
            IPsiSourceFile psiSourceFile = document.GetPsiSourceFile(solution);
            if (psiSourceFile != null)
            {
                // todo make this resolvable also via the AllTypes... line
                var invokedNode = dataContext.GetSelectedTreeNode<IExpression>();

                return solution.GetComponent<SolutionAnalyzer>()
                               .Analyze()
                               .Any(r => r.Registration.RegistrationElement.Children().Contains(invokedNode));
            }

            return false;
        }

        protected ICollection<IDeclaredElement> GetAdditionalElementsToSearch(IDataContext context)
        {
            var selectedConstructorDeclaration = context.GetSelectedTreeNode<IConstructorDeclaration>();

            if (selectedConstructorDeclaration != null)
            {
                var selectedTypeDeclaration = selectedConstructorDeclaration.GetContainingTypeDeclaration();

                if (selectedTypeDeclaration != null)
                {
                    ISearchDomain searchDomain = SearchDomainFactory.Instance.CreateSearchDomain(selectedTypeDeclaration.GetPsiModule().GetSolution(), false);
                    var referencesToSelectedType = selectedTypeDeclaration
                        .GetPsiServices()
                        .Finder
                        .FindReferences(selectedTypeDeclaration.DeclaredElement, searchDomain, NullProgressIndicator.Instance);
                    
                    var referencesToSelectedTypeExpressions = referencesToSelectedType
                        .Select(o => o.GetTreeNode().GetContainingNode<IReferenceExpression>())
                        .Where(o => o != null);

                    var createMethods = new Collection<IDeclaredElement>();

                    foreach (var referenceExpression in referencesToSelectedTypeExpressions)
                    {
                        var creatingFactory = ((IReferenceExpression)referenceExpression.FirstChild.FirstChild)
                            .TypeArgumentList
                            .TypeArguments[0];

                        // Find all the calls to IxxxFactory.Create() 
                        var factoryInterface = ((Interface)creatingFactory.GetScalarType().Resolve().DeclaredElement);                                   


                        Func<IDeclaredType, IList<IDeclaredType>> recursionForFindingAllSuperTypes = null;
                        recursionForFindingAllSuperTypes = type =>
                            {
                                var ancestorDirectSuperTypes = new List<IDeclaredType>();
                                foreach (var ancestor in type.GetSuperTypes())
                                {
                                    IEnumerable<IDeclaredType> superTypes = recursionForFindingAllSuperTypes(ancestor);

                                    ancestorDirectSuperTypes.AddRange(superTypes);
                                }
                                return ancestorDirectSuperTypes;
                            };

                        var allSuperclasses = factoryInterface.GetAllSuperTypes();                       

                        IEnumerable<IMethod> allMethods = allSuperclasses
                            .Where(o => o.GetClrName().FullName != typeof(Object).FullName)
                            .Select(o =>  o.GetScalarType().GetTypeElement())
                            .SelectMany(o => o.Methods)
                            .Concat(factoryInterface.Methods);

                        // FIXME : we are only handling the methods of the interface, not the inherited methods !
                        var createMethodsForReference =
                            allMethods.Where(
                                o =>
                                    {                                        
                                        var substitutions = allSuperclasses
                                            .Select(x => x.GetSubstitution())
                                            .Where(s => s.Domain.Count > 0);

                                        var hasGenericSuperType = substitutions.Any();

                                        // todo : we still have to make sure we only keep the typeParameters which are compatible with the selected .ctor.
                                        IEnumerable<IType> typeParameters = substitutions
                                            .SelectMany(x => x.Domain, (singleSubstitution, typeParameter) => singleSubstitution[typeParameter])
                                            .Where(x => x != null);                                                                                
                                        var typeReturnedByMethodOfFactory = o.ReturnType.GetScalarType().GetTypeElement();
                                        var isDescendant = selectedTypeDeclaration.DeclaredElement.IsDescendantOf(typeReturnedByMethodOfFactory);
                                        if (hasGenericSuperType)
                                        {
                                            // if we have a generic factory interface : let's check if one of the type arguments do match the output value of a method.                                            
                                            isDescendant = selectedTypeDeclaration.DeclaredElement.GetAllSuperTypes().Union(typeParameters).Any();                                            
                                        }
                                        return isDescendant;
                                    })
                                    .SelectMany(o => o.GetDeclarations(), (method, declaration) => declaration.DeclaredElement);                        
                            createMethods.AddRange(createMethodsForReference);                                              
                    }
                    return createMethods;
                }
            }
            return new IDeclaredElement[0];
        }