コード例 #1
0
		/// <summary>
		/// Finds all references to the specified entity.
		/// The results are reported using the callback.
		/// FindReferences may internally use parallelism, and may invoke the callback on multiple
		/// threads in parallel.
		/// </summary>
		public static async Task FindReferencesAsync(IEntity entity, IProgressMonitor progressMonitor, Action<SearchedFile> callback)
		{
			if (entity == null)
				throw new ArgumentNullException("entity");
			if (progressMonitor == null)
				throw new ArgumentNullException("progressMonitor");
			if (callback == null)
				throw new ArgumentNullException("callback");
			SD.MainThread.VerifyAccess();
			if (SD.ParserService.LoadSolutionProjectsThread.IsRunning) {
				progressMonitor.ShowingDialog = true;
				MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}");
				progressMonitor.ShowingDialog = false;
				return;
			}
			double totalWorkAmount;
			List<ISymbolSearch> symbolSearches = PrepareSymbolSearch(entity, progressMonitor.CancellationToken, out totalWorkAmount);
			double workDone = 0;
			ParseableFileContentFinder parseableFileContentFinder = new ParseableFileContentFinder();
			foreach (ISymbolSearch s in symbolSearches) {
				progressMonitor.CancellationToken.ThrowIfCancellationRequested();
				using (var childProgressMonitor = progressMonitor.CreateSubTask(s.WorkAmount / totalWorkAmount)) {
					await s.FindReferencesAsync(new SymbolSearchArgs(childProgressMonitor, parseableFileContentFinder), callback);
				}
				
				workDone += s.WorkAmount;
				progressMonitor.Progress = workDone / totalWorkAmount;
			}
		}
コード例 #2
0
		/// <summary>
		/// This method can be used in three modes:
		/// 1. Find references to classes (parentClass = targetClass, member = null, fileName = null)
		/// 2. Find references to members (parentClass = parent, member = member, fileName = null)
		/// 3. Find references to local variables (parentClass = parent, member = local var as field, fileName = parent.CompilationUnit.FileName)
		/// </summary>
		static List<Reference> RunFindReferences(IClass ownerClass, IMember member,
		                                         string fileName,
		                                         IProgressMonitor progressMonitor)
		{
			if (ParserService.LoadSolutionProjectsThreadRunning) {
				if (progressMonitor != null) progressMonitor.ShowingDialog = true;
				MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}");
				if (progressMonitor != null) progressMonitor.ShowingDialog = false;
				return null;
			}
			
			CancellationToken ct = progressMonitor != null ? progressMonitor.CancellationToken : CancellationToken.None;
			
			List<ProjectItem> files;
			if (!string.IsNullOrEmpty(fileName)) {
				// search just in given file
				files = new List<ProjectItem>();
				files.Add(FindItem(fileName));
			} else {
				// search in all possible files
				ownerClass = ownerClass.GetCompoundClass();
				files = GetPossibleFiles(ownerClass, member);
			}
			ParseableFileContentFinder finder = new ParseableFileContentFinder();
			List<Reference> references = new List<Reference>();
			
			if (progressMonitor != null)
				progressMonitor.TaskName = StringParser.Parse("${res:SharpDevelop.Refactoring.FindingReferences}");
			
			foreach (ProjectItem item in files) {
				FileName itemFileName = FileName.Create(item.FileName);
				
				if (progressMonitor != null) {
					progressMonitor.Progress += 1.0 / files.Count;
					if (ct.IsCancellationRequested)
						return null;
				}
				// Don't read files we don't have a parser for.
				// This avoids loading huge files (e.g. sdps) when we have no intention of parsing them.
				if (ParserService.GetParser(itemFileName) != null) {
					ITextBuffer content = finder.Create(itemFileName);
					if (content != null) {
						try {
							AddReferences(references, ownerClass, member, itemFileName, content.Text, ct);
						} catch (OperationCanceledException ex) {
							if (ex.CancellationToken == ct)
								return null;
							else
								throw;
						}
					}
				}
			}
			
			return references;
		}
コード例 #3
0
		internal void Initialize2(IProgressMonitor progressMonitor)
		{
			if (!initializing) return;
			try {
				IProjectContent[] referencedContents;
				lock (this.ReferencedContents) {
					referencedContents = new IProjectContent[this.ReferencedContents.Count];
					this.ReferencedContents.CopyTo(referencedContents, 0);
				}
				
				foreach (IProjectContent referencedContent in referencedContents) {
					if (referencedContent is ReflectionProjectContent) {
						((ReflectionProjectContent)referencedContent).InitializeReferences();
					}
				}
				
				ParseableFileContentFinder finder = new ParseableFileContentFinder();
				var fileContents = (
					from p in project.Items.AsParallel().WithCancellation(progressMonitor.CancellationToken)
					where !ItemType.NonFileItemTypes.Contains(p.ItemType) && !String.IsNullOrEmpty(p.FileName)
					select FileName.Create(p.FileName)
				).ToList();
				
				object progressLock = new object();
				double fileCountInverse = 1.0 / fileContents.Count;
				Parallel.ForEach(
					fileContents,
					new ParallelOptions {
						MaxDegreeOfParallelism = Environment.ProcessorCount * 2,
						CancellationToken = progressMonitor.CancellationToken
					},
					fileName => {
						// Don't read files we don't have a parser for.
						// This avoids loading huge files (e.g. sdps) when we have no intention of parsing them.
						if (ParserService.GetParser(fileName) != null) {
							ITextBuffer content = finder.Create(fileName);
							if (content != null)
								ParserService.ParseFile(this, fileName, content);
						}
						lock (progressLock) {
							progressMonitor.Progress += fileCountInverse;
						}
					}
				);
			} finally {
				initializing = false;
				progressMonitor.Progress = 1;
			}
		}
コード例 #4
0
		public SymbolRenameArgs(string newName, IProgressMonitor progressMonitor, ParseableFileContentFinder parseableFileContentFinder)
			: base(progressMonitor, parseableFileContentFinder)
		{
			if (newName == null)
				throw new ArgumentNullException("newName");
			NewName = newName;
		}
コード例 #5
0
		public SymbolSearchArgs(IProgressMonitor progressMonitor, ParseableFileContentFinder parseableFileContentFinder)
		{
			if (progressMonitor == null)
				throw new ArgumentNullException("progressMonitor");
			if (parseableFileContentFinder == null)
				throw new ArgumentNullException("parseableFileContentFinder");
			this.ProgressMonitor = progressMonitor;
			this.ParseableFileContentFinder = parseableFileContentFinder;
			this.ProvideHighlightedLine = true;
		}
コード例 #6
0
		public static async Task RenameSymbolAsync(ISymbol symbol, string newName, IProgressMonitor progressMonitor, Action<Error> errorCallback)
		{
			if (symbol == null)
				throw new ArgumentNullException("symbol");
			if (progressMonitor == null)
				throw new ArgumentNullException("progressMonitor");
			SD.MainThread.VerifyAccess();
			if (SD.ParserService.LoadSolutionProjectsThread.IsRunning) {
				progressMonitor.ShowingDialog = true;
				MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}");
				progressMonitor.ShowingDialog = false;
				return;
			}
			double totalWorkAmount;
			List<ISymbolSearch> symbolSearches = PrepareSymbolSearch(symbol, progressMonitor.CancellationToken, out totalWorkAmount);
			double workDone = 0;
			ParseableFileContentFinder parseableFileContentFinder = new ParseableFileContentFinder();
			var errors = new List<Error>();
			var changes = new List<PatchedFile>();
			foreach (ISymbolSearch s in symbolSearches) {
				progressMonitor.CancellationToken.ThrowIfCancellationRequested();
				using (var childProgressMonitor = progressMonitor.CreateSubTask(s.WorkAmount / totalWorkAmount)) {
					var args = new SymbolRenameArgs(newName, childProgressMonitor, parseableFileContentFinder);
					args.ProvideHighlightedLine = false;
					await s.RenameAsync(args, file => changes.Add(file), error => errors.Add(error));
				}
				
				workDone += s.WorkAmount;
				progressMonitor.Progress = workDone / totalWorkAmount;
			}
			if (errors.Count == 0) {
				foreach (var file in changes) {
					ApplyChanges(file);
				}
			} else {
				foreach (var error in errors) {
					errorCallback(error);
				}
			}
		}
コード例 #7
0
		void DoReparseCode(List<FileName> filesToParse, IProgressMonitor progressMonitor)
		{
			ParseableFileContentFinder finder = new ParseableFileContentFinder();
			double fileCountInverse = 1.0 / filesToParse.Count;
			object progressLock = new object();
			Parallel.ForEach(
				filesToParse,
				new ParallelOptions {
					MaxDegreeOfParallelism = Environment.ProcessorCount,
					CancellationToken = progressMonitor.CancellationToken
				},
				fileName => {
					// Clear cached parse information so that the file is forced to be reparsed even if it is unchanged
					parserService.ClearParseInformation(fileName);
					
					ITextSource content = finder.Create(fileName);
					if (content != null) {
						parserService.ParseFile(fileName, content, project);
					}
					lock (progressLock) {
						progressMonitor.Progress += fileCountInverse;
					}
				});
		}
コード例 #8
0
		void ParseFiles(List<FileName> filesToParse, IProgressMonitor progressMonitor)
		{
			IProjectContent cachedPC = TryReadFromCache(cacheFileName);
			ParseableFileContentFinder finder = new ParseableFileContentFinder();
			
			object progressLock = new object();
			double fileCountInverse = 1.0 / filesToParse.Count;
			int fileCountLoadedFromCache = 0;
			int fileCountParsed = 0;
			int fileCountParsedAndSerializable = 0;
			Parallel.ForEach(
				filesToParse,
				new ParallelOptions {
					MaxDegreeOfParallelism = Environment.ProcessorCount,
					CancellationToken = progressMonitor.CancellationToken
				},
				fileName => {
					ITextSource content = finder.CreateForOpenFile(fileName);
					bool wasLoadedFromCache = false;
					IUnresolvedFile unresolvedFile = null;
					if (content == null && cachedPC != null) {
						unresolvedFile = cachedPC.GetFile(fileName);
						if (unresolvedFile != null && unresolvedFile.LastWriteTime == File.GetLastWriteTimeUtc(fileName)) {
							parserService.RegisterUnresolvedFile(fileName, project, unresolvedFile);
							wasLoadedFromCache = true;
						}
					}
					if (!wasLoadedFromCache) {
						if (content == null) {
							try {
								content = SD.FileService.GetFileContentFromDisk(fileName);
							} catch (IOException) {
							} catch (UnauthorizedAccessException) {
							}
						}
						if (content != null) {
							unresolvedFile = parserService.ParseFile(fileName, content, project);
						}
					}
					lock (progressLock) {
						if (wasLoadedFromCache) {
							fileCountLoadedFromCache++;
						} else {
							fileCountParsed++;
							if (IsSerializable(unresolvedFile))
								fileCountParsedAndSerializable++;
						}
						SD.MainThread.InvokeAsyncAndForget(delegate { assemblyModel.Update(null, unresolvedFile); });
						progressMonitor.Progress += fileCountInverse;
					}
				});
			LoggingService.Debug(projectContent.AssemblyName + ": ParseFiles() finished. "
			                     + fileCountLoadedFromCache + " files were re-used from CC cache; "
			                     + fileCountParsed + " files were parsed (" + fileCountParsedAndSerializable + " of those are serializable)");
			lock (lockObj) {
				serializedProjectContentIsUpToDate = (fileCountLoadedFromCache > 0 && fileCountParsedAndSerializable == 0);
			}
		}
コード例 #9
0
		/// <summary>
		/// This method can be used in three modes:
		/// 1. Find references to classes (parentClass = targetClass, member = null, fileName = null)
		/// 2. Find references to members (parentClass = parent, member = member, fileName = null)
		/// 3. Find references to local variables (parentClass = parent, member = local var as field, fileName = parent.CompilationUnit.FileName)
		/// </summary>
		static List<Reference> RunFindReferences(IClass ownerClass, IMember member,
		                                         string fileName,
		                                         IProgressMonitor progressMonitor)
		{
			if (ParserService.LoadSolutionProjectsThreadRunning) {
				if (progressMonitor != null) progressMonitor.ShowingDialog = true;
				MessageService.ShowMessage("${res:SharpDevelop.Refactoring.LoadSolutionProjectsThreadRunning}");
				if (progressMonitor != null) progressMonitor.ShowingDialog = false;
				return null;
			}
			List<ProjectItem> files;
			if (!string.IsNullOrEmpty(fileName)) {
				// search just in given file
				files = new List<ProjectItem>();
				files.Add(FindItem(fileName));
			} else {
				// search in all possible files
				ownerClass = ownerClass.GetCompoundClass();
				files = GetPossibleFiles(ownerClass, member);
			}
			ParseableFileContentFinder finder = new ParseableFileContentFinder();
			List<Reference> references = new List<Reference>();
			
			if (progressMonitor != null)
				progressMonitor.TaskName = StringParser.Parse("${res:SharpDevelop.Refactoring.FindingReferences}");
			
			foreach (ProjectItem item in files) {
				FileName itemFileName = FileName.Create(item.FileName);
				
				if (progressMonitor != null) {
					progressMonitor.Progress += 1.0 / files.Count;
					if (progressMonitor.CancellationToken.IsCancellationRequested)
						return null;
				}
				
				ITextBuffer content = finder.Create(itemFileName);
				if (content != null) {
					AddReferences(references, ownerClass, member, itemFileName, content.Text);
				}
			}
			
			return references;
		}
コード例 #10
0
		void SearchForIssues(List<FileName> fileNames, IEnumerable<IssueManager.IssueProvider> providers, Action<SearchedFile> callback, IProgressMonitor monitor)
		{
			// used for debugging so that we can break in the crashing issue
			ParseableFileContentFinder contentFinder = new ParseableFileContentFinder();
			int filesProcessed = 0;
			foreach (FileName fileName in fileNames) {
				var fileContent = contentFinder.Create(fileName);
				var resultForFile = SearchForIssues(fileName, fileContent, providers, monitor.CancellationToken);
				if (resultForFile != null) {
					callback(resultForFile);
				}
				monitor.Progress = (double)(++filesProcessed) / fileNames.Count;
			}
		}
コード例 #11
0
		void SearchForIssuesParallel(List<FileName> fileNames, IEnumerable<IssueManager.IssueProvider> providers, Action<SearchedFile> callback, IProgressMonitor monitor)
		{
			ParseableFileContentFinder contentFinder = new ParseableFileContentFinder();
			int filesProcessed = 0;
			Parallel.ForEach(
				fileNames,
				new ParallelOptions {
					MaxDegreeOfParallelism = Environment.ProcessorCount,
					CancellationToken = monitor.CancellationToken
				},
				delegate (FileName fileName) {
					var fileContent = contentFinder.Create(fileName);
					try {
						var resultForFile = SearchForIssues(fileName, fileContent, providers, monitor.CancellationToken);
						if (resultForFile != null) {
							callback(resultForFile);
						}
					} catch (IOException) {
						// ignore IO exceptions (e.g. a file is missing)
					} catch (OperationCanceledException) {
						throw;
					} catch (Exception ex) {
						throw new ApplicationException("Exception while searching for issues in " + fileName, ex);
					}
					monitor.Progress = (double)Interlocked.Increment(ref filesProcessed) / fileNames.Count;
				});
		}
コード例 #12
0
		void InsertEventHandlerInternal(string methodName, IEvent evt)
		{
			CSharpCodeGenerator generator = new CSharpCodeGenerator();
			var primary = loader.GetPrimaryTypeDefinition();
			var evtHandler = primary.GetMethods(m => m.Name == methodName, GetMemberOptions.IgnoreInheritedMembers).FirstOrDefault();
			if (evtHandler == null) {
				generator.InsertEventHandler(primary, methodName, evt, true);
			} else {
				CSharpBinding.Parser.CSharpFullParseInformation parseInfo;
				var node = evtHandler.GetDeclaration(out parseInfo) as MethodDeclaration;
				var fileName = new FileName(evtHandler.Region.FileName);
				var fileContentFinder = new ParseableFileContentFinder();
				
				if (node != null && !node.Body.IsNull) {
					var location = node.Body.FirstChild.StartLocation;
					var firstStatement = node.Body.Children.OfType<Statement>().FirstOrDefault();
					
					if (firstStatement == null) {
						var fileContent = fileContentFinder.Create(fileName);
						var document = new ReadOnlyDocument(fileContent);
						var offset = document.GetOffset(new TextLocation(location.Line + 1, 1));
						var length = DocumentUtilities.GetWhitespaceAfter(fileContent, offset).Length;
						location = new TextLocation(location.Line + 1, length + 1);
					} else {
						location = firstStatement.StartLocation;
					}
					SD.FileService.JumpToFilePosition(fileName, location.Line, location.Column);
				}
			}
		}