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;
}
});
}
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;
});
}
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(referencedContents);
}
}
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;
}
}
public SymbolRenameArgs(string newName, IProgressMonitor progressMonitor, ParseableFileContentFinder parseableFileContentFinder)
: base(progressMonitor, parseableFileContentFinder)
{
if (newName == null)
{
throw new ArgumentNullException("newName");
}
NewName = newName;
}
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);
}
}
}
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;
}
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;
}
}
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)
{
var insertionType = GeneralOptionsPanel.InsertTodoComment ? InsertEventHandlerBodyKind.TodoComment : InsertEventHandlerBodyKind.Nothing;
generator.InsertEventHandler(primary, methodName, evt, true, insertionType);
}
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);
}
}
}
/// <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;
}
}
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);
}
}
/// <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);
}
