C# IDeclaredElement.GetPsiServices方法代码示例

    public GeneratedClassSearchRequest(IDeclaredElement declaredElement)
    {
      if (declaredElement == null)
        throw new ArgumentNullException("declaredElement");
      Logger.Assert(declaredElement.IsValid(), "declaredElement should be valid");

      mySolution = declaredElement.GetPsiServices().Solution;
      var ruleDeclaration = declaredElement as RuleDeclaration;
      if( ruleDeclaration == null)
        throw new ArgumentNullException("ruleDeclaration");

      if (ruleDeclaration.DerivedClasses.Count() > 0)
      {
        myTarget = new DeclaredElementEnvoy<IDeclaredElement>(ruleDeclaration.DerivedClasses.First());
      }
      else
      {
        myTarget = new DeclaredElementEnvoy<IDeclaredElement>(declaredElement);
      }
    }

    public CSharpToPsiSearchRequest(IDeclaredElement declaredElement)
    {
      if (declaredElement == null)
        throw new ArgumentNullException("declaredElement");
      Logger.Assert(declaredElement.IsValid(), "declaredElement should be valid");

      mySolution = declaredElement.GetPsiServices().Solution;


      var @class = declaredElement as IClass;
      if (@class != null)
      {
        myTarget = new DeclaredElementEnvoy<IDeclaredElement>(DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForClass(@class));
      }

      var @method = declaredElement as IMethod;
      if (@method != null)
      {
        myTarget = new DeclaredElementEnvoy<IDeclaredElement>(DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForMethod(@method));
      }

      var @interface = declaredElement as IInterface;
      if (@interface != null)
      {
        myTarget = new DeclaredElementEnvoy<IDeclaredElement>(DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForInterface(@interface));
      }

      var @constructor = declaredElement as IConstructor;

      if(@constructor != null)
      {
        @class = @constructor.GetContainingType() as IClass;

        if(@class != null)
        {
          myTarget = new DeclaredElementEnvoy<IDeclaredElement>(DerivedDeclaredElementUtil.GetPrimaryDeclaredElementForClass(@class));
        }
      }
    }

 private static IDeclaredElement GetPrimaryDeclaredElementForVisitorMethod(IDeclaredElement declaredElement, IMethod method)
 {
   var cache = declaredElement.GetPsiServices().Solution.GetComponent<PsiCache>();
   Dictionary<ITypeElement, IList<PsiOptionSymbol>> classesWithInfo = GetVisitorClasses(cache);
   if (classesWithInfo.Count > 0)
   {
     var parentClass = method.GetContainingType() as IClass;
     if (parentClass != null)
     {
       if (classesWithInfo.ContainsKey(parentClass))
       {
         IList<PsiOptionSymbol> list = classesWithInfo[parentClass];
         PsiOptionSymbol visitorName = list[0];
         PsiOptionSymbol methodSuffix = list[1];
         PsiOptionSymbol methodPrefix = list[2];
         IPsiSourceFile sourceFile = visitorName.SourceFile;
         string name = method.ShortName;
         if (name.Length > methodPrefix.Value.Length + methodSuffix.Value.Length)
         {
           if (methodPrefix.Value.Length > 0)
           {
             name = name.Substring(methodPrefix.Value.Length, name.Length - methodPrefix.Value.Length);
           }
           if (methodSuffix.Value.Length > 0)
           {
             name = name.Substring(0, name.Length - methodSuffix.Value.Length);
           }
           IEnumerable<IPsiSymbol> elements = cache.GetSymbols(NameFromCamelCase(name));
           foreach (IPsiSymbol psiSymbol in elements)
           {
             if (psiSymbol.SourceFile == sourceFile)
             {
               var psiFile = sourceFile.GetPsiFile<PsiLanguage>(new DocumentRange(psiSymbol.SourceFile.Document, 0)) as PsiFile;
               if (psiFile != null)
               {
                 IList<ISymbolInfo> infos = psiFile.FileRuleSymbolTable.GetSymbolInfos(name);
                 foreach (ISymbolInfo info in infos)
                 {
                   IDeclaredElement element = info.GetDeclaredElement();
                   if (element is RuleDeclaration)
                   {
                     var ruleDeclaration = element as RuleDeclaration;
                     {
                       return ruleDeclaration;
                     }
                   }
                 }
               }
             }
           }
         }
         else
         {
           {
             return null;
           }
         }
       }
     }
   }
   {
     return null;
   }
 }

			private bool EvalTestPartPredicate(IDeclaredElement element, Predicate<TestPart> predicate)
			{
				if (!element.IsValid())
					return false;

				try
				{
#if RESHARPER_60
					var reflectionPolicy = new PsiReflectionPolicy(element.GetPsiServices().PsiManager);
#else
					var reflectionPolicy = new PsiReflectionPolicy(element.GetPsiServices().PsiManager, provider.CacheManager);
#endif
					var elementInfo = reflectionPolicy.Wrap(element);
					if (elementInfo == null)
						return false;

					var driver = CreateTestDriver();
					var testParts = driver.GetTestParts(reflectionPolicy, elementInfo);
					return GenericCollectionUtils.Exists(testParts, predicate);
				}
				catch (Exception ex)
				{
					HandleEmbeddedProcessCancelledException(ex);
					throw;
				}
			}