C# ITreeNode.GetSourceFile方法代码示例

 public CreatePsiRuleContext(CreatePsiRuleTarget target)
 {
   myTarget = target;
   myAnchor = target.Anchor;
   myOffset = myAnchor.GetNavigationRange().TextRange.EndOffset;
   myDocument = myAnchor.GetSourceFile().Document;
   myRuleName = myTarget.Reference.GetTreeNode() as IRuleName;
 }

        public static string CatchVariableName(ITreeNode treeNode, IDeclaredType exceptionType)
        {
            var namingPolicyManager = new NamingPolicyManager(LanguageManager.Instance, treeNode.GetSolution());
            var nameParser = new NameParser(treeNode.GetSolution(), namingPolicyManager);
            var nameSuggestionManager = new NameSuggestionManager(treeNode.GetSolution(), nameParser, namingPolicyManager);
            var policy = namingPolicyManager.GetPolicy(NamedElementKinds.Locals, treeNode.Language, treeNode.GetSourceFile());

            var namesCollection = nameSuggestionManager.CreateEmptyCollection(
                PluralityKinds.Single, treeNode.Language, true, treeNode.GetSourceFile());

            var entryOptions = new EntryOptions
            {
                PluralityKind = PluralityKinds.Single,
                PredefinedPrefixPolicy = PredefinedPrefixPolicy.Preserve,
                Emphasis = Emphasis.Good,
                SubrootPolicy = SubrootPolicy.Decompose
            };

            namesCollection.Add(exceptionType, entryOptions);
            namesCollection.Prepare(policy.NamingRule, ScopeKind.Common, new SuggestionOptions());

            return namesCollection.FirstName();
        }

 private static string SuggestVariableName(ITreeNode context, string name)
 {
     return context.GetPsiServices().Naming.Suggestion
         .GetDerivedName(name,
             NamedElementKinds.Locals,
             ScopeKind.Common,
             context.Language,
             new SuggestionOptions
             {
                 DefaultName = name,
                 UniqueNameContext = context
             },
             context.GetSourceFile());
 }

        public void ProcessBeforeInterior(ITreeNode element)
        {
            var functionDeclaration = element as ICSharpFunctionDeclaration;
            if (functionDeclaration == null)
                return;
            var psiModule = element.GetPsiModule();
            var sourceFile = element.GetSourceFile();
            if (sourceFile == null)
                return;
            var resolveContext = sourceFile.ResolveContext;
            var disposableInterface = DisposeUtil.GetDisposableInterface(psiModule, resolveContext);
            if (disposableInterface == null)
                return;
            var graf = CSharpControlFlowBuilder.Build(functionDeclaration) as CSharpControlFlowGraf;
            if (graf == null)
                return;

            var name = functionDeclaration.DeclaredName;
            var offset = InvokedExpressionData.GetOffsetByNode(functionDeclaration);

            var grafInspector = new ControlFlowInspector(functionDeclaration, graf, disposableInterface);
            var methodArguments = grafInspector.GetMethodArgumentStatuses();
            _statuses.Add(new DisposeMethodStatus(name, offset, methodArguments, sourceFile));
        }

		void ICache.OnPsiChange(ITreeNode elementContainingChanges, PsiChangedElementType type)
		{
			if (elementContainingChanges == null) return;

			var sourceFile = elementContainingChanges.GetSourceFile();
			if ((sourceFile != null) && sourceFile.PrimaryPsiLanguage.Is<JavaScriptLanguage>())
			{
				lock (_lock)
				{
					_dirtyFiles.Add(sourceFile);
				}
			}
		}

                public ConsumerAdapter(GallioTestProvider provider, UnitTestElementLocationConsumer consumer, ITreeNode psiFile)
                    : this(provider, delegate(IUnitTestElement element)
                    {
                        var projectFile = psiFile.GetSourceFile().ToProjectFile();

                    	if (projectFile == null || !projectFile.IsValid()) 
							return;

                        consumer(element.GetDisposition());
                    })
                {
                }

        	/// <summary>
            /// Explores given PSI file.
            /// </summary>
			public void ExploreFile(ITreeNode psiFile, UnitTestElementLocationConsumer consumer, CheckForInterrupt interrupted)
        	{
        		if (psiFile == null)
        			throw new ArgumentNullException("psiFile");
        		if (consumer == null)
        			throw new ArgumentNullException("consumer");

        		if (!psiFile.IsValid())
        			return;

        		try
        		{
#if RESHARPER_60
        			var reflectionPolicy = new PsiReflectionPolicy(psiFile.GetPsiServices().PsiManager);
#else
					var reflectionPolicy = new PsiReflectionPolicy(psiFile.GetPsiServices().PsiManager, provider.CacheManager);
#endif
        			var consumerAdapter = new ConsumerAdapter(provider, consumer, psiFile);

        			var codeElements = new List<ICodeElementInfo>();
        			psiFile.ProcessDescendants(new OneActionProcessorWithoutVisit(delegate(ITreeNode element)
					{
						var declaration = element as ITypeDeclaration;
						if (declaration != null)
							PopulateCodeElementsFromTypeDeclaration(codeElements, reflectionPolicy, declaration);
					}, delegate(ITreeNode element)
					{
						if (interrupted())
							throw new ProcessCancelledException();

						// Stop recursing at the first type declaration found.
						return element is ITypeDeclaration;
					}));

        			Describe(reflectionPolicy, codeElements, consumerAdapter);

        			ProjectFileState.SetFileState(psiFile.GetSourceFile().ToProjectFile(), consumerAdapter.CreateProjectFileState());
        		}
        		catch (Exception ex)
        		{
        			HandleEmbeddedProcessCancelledException(ex);
        			throw;
        		}
        	}