public void Finish(RepoProject repoProject)
{
foreach (var entry in ReferenceDefinitionMap)
{
var def = entry.Value;
var project = ReferencedProjects.GetOrAdd(def.ProjectId, id => new ReferencedProject()
{
ProjectId = id,
DisplayName = id,
});
project.Definitions.Add(def);
}
foreach (var referencedProject in ReferencedProjects.Values.OrderBy(rp => rp.ProjectId, StringComparer.OrdinalIgnoreCase))
{
if (referencedProject.ProjectId != Project.Id)
{
Project.ReferencedProjects.Add(referencedProject);
}
// Remove all the namespaces
referencedProject.Definitions.RemoveAll(ds => ds.Kind == nameof(SymbolKind.Namespace));
// Sort the definitions by qualified name
referencedProject.Definitions.Sort((d1, d2) => d1.DisplayName.CompareTo(d2.DisplayName));
}
//CreateNamespaceFile();
CreateReferencedProjectFiles(repoProject);
}
public override async Task Analyze(RepoProject project)
{
var assembly = assemblyFileByMetadataAsSourceProjectPath[project.ProjectDirectory];
try
{
var solution = await MetadataAsSource.LoadMetadataAsSourceSolution(assembly, project.ProjectDirectory);
if (solution == null)
{
return;
}
var proj = solution.Projects.Single();
var projectInfo = ProjectInfo.Create(proj.Id, VersionStamp.Create(), project.ProjectId, project.ProjectId, LanguageNames.CSharp,
documents: proj.Documents.Select(d => DocumentInfo.Create(d.Id, d.Name, filePath: d.FilePath, folders: d.Folders)));
SolutionProjectAnalyzer.AddSolutionProject(
new Lazy <Task <Microsoft.CodeAnalysis.Solution> >(() => Task.FromResult(solution)),
projectInfo,
project.ProjectFile,
project,
csharpSemanticServices: new Lazy <SemanticServices>(() => new SemanticServices(solution.Workspace, LanguageNames.CSharp)));
if (project.Analyzer != this)
{
await project.Analyzer.Analyze(project);
}
}
catch
{
}
}
public override async void Analyze(RepoProject project)
{
var logger = project.Repo.AnalysisServices.Logger;
try
{
var services = project.Repo.AnalysisServices;
logger.LogMessage("Loading project: " + project.ProjectId);
using (services.TaskDispatcher.TrackScope())
{
await services.TaskDispatcher.Invoke(async() =>
{
var solution = await lazySolution.Value;
Project = solution.GetProject(ProjectId);
if (Project == null)
{
logger.LogError($"Can't find project for {ProjectId} in {solution}");
}
else
{
Compilation = await Project.GetCompilationAsync();
CompilationServices = new CompilationServices(Compilation);
foreach (var reference in Compilation.ReferencedAssemblyNames)
{
var referencedProject = new ReferencedProject()
{
ProjectId = reference.Name,
DisplayName = reference.GetDisplayName(),
Properties = new Dictionary <string, string>()
{
{ "PublicKey", string.Concat(reference.PublicKey.Select(b => b.ToString("X2"))) }
}
};
ProjectContext.ReferencedProjects.TryAdd(referencedProject.ProjectId, referencedProject);
}
}
base.Analyze(project);
});
var documents = await Task.WhenAll(DocumentAnalysisTasks);
ProjectContext.Finish(project);
UploadProject(project, ProjectContext.Project);
project.Analyzer = RepoProjectAnalyzer.Null;
}
}
catch (Exception ex)
{
logger.LogExceptionError($"Loading project {project.ProjectId}", ex);
}
}
public override void Initialize(Repo repo)
{
base.Initialize(repo);
if (AddImports)
{
repo.AnalysisServices.TaskDispatcher.QueueInvoke(async() =>
{
MSBuildSharedRepo = await repo.AnalysisServices.CreateRepo(MSBuildSharedRepoName);
MSBuildSharedProject = MSBuildSharedRepo.CreateRepoProject(MSBuildProjectId, @"\\msbuild\");
});
}
}
private void CreateReferencedProjectFiles(RepoProject repoProject)
{
foreach (var project in ReferencedProjects.Values)
{
if (project.Definitions.Count == 0)
{
continue;
}
CreateMetadataFile(repoProject, GetProjectReferenceSymbolsPath(project.ProjectId), () =>
{
XElement container = null;
return(Element("ReferenceSymbols")
.AddAttribute("Count", project.Definitions.Count)
.ForEach(project.Definitions, (el, definition) =>
{
var nsdata = definition.ExtData as NamespaceExtensionData;
container = nsdata?.GetNamespaceElement(el) ?? el;
if (definition.DisplayName.StartsWith(nsdata?.Qualifier ?? string.Empty))
{
ReferenceSymbol reference = definition;
reference.ReferenceKind = nameof(ReferenceKind.ProjectLevelReference);
reference.ExcludeFromSearch = true;
container.AddElement("Symbol", symbolElement =>
symbolElement
.AddAttribute("Name", definition.DisplayName
.Substring(nsdata?.Qualifier.Length ?? 0), reference)
.AddAttribute("ReferenceCount", definition.ReferenceCount.ToString()));
}
}));
});
}
CreateMetadataFile(repoProject, "ReferenceProjects.xml", () =>
{
return(Element("ReferenceProjects").ForEach(ReferencedProjects.Values
.OrderBy(rp => rp.ProjectId, StringComparer.OrdinalIgnoreCase)
.ThenBy(rp => rp.DisplayName, StringComparer.OrdinalIgnoreCase), (el, project) =>
{
ReferenceSymbol fileRef = project.Definitions.Count == 0 ? null : CreateFileReferenceSymbol(
GetMetadataFilePath(GetProjectReferenceSymbolsPath(project.ProjectId)),
Project.Id);
el.AddElement("Project", projElement =>
projElement
.AddAttribute("ReferenceCount", project.Definitions.Count.ToString(), fileRef)
.AddAttribute("Name", project.ProjectId)
.AddAttribute("FullName", project.DisplayName));
}));
});
}
public static void AddSolutionProject(
Lazy <Task <Solution> > lazySolution,
ProjectInfo projectInfo,
RepoFile projectFile,
RepoProject repoProject,
Lazy <SemanticServices> csharpSemanticServices = null,
Lazy <SemanticServices> visualBasicSemanticServices = null)
{
var semanticServices = projectInfo.Language == LanguageNames.CSharp ?
csharpSemanticServices :
visualBasicSemanticServices;
Contract.Assert(semanticServices.Value != null);
var projectAnalyzer = new ManagedProjectAnalyzer(
semanticServices.Value,
repoProject,
projectInfo.Id,
lazySolution);
if (projectFile != null)
{
projectFile.HasExplicitAnalyzer = true;
}
repoProject.Analyzer = projectAnalyzer;
foreach (var document in projectInfo.Documents)
{
if (document == null)
{
throw new ArgumentNullException($"Project {projectInfo.Id} has a null document.");
}
if (Path.GetFileName(document.FilePath).StartsWith("TemporaryGeneratedFile_", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var file = AddDocumentToProject(repoProject, document);
if (file != null && projectAnalyzer != null)
{
file.Analyzer = projectAnalyzer.CreateFileAnalyzer(document);
}
}
foreach (var document in projectInfo.AdditionalDocuments)
{
AddDocumentToProject(repoProject, document);
}
}
public virtual void Analyze(RepoProject project)
{
project.Repo.AnalysisServices.Logger.WriteLine($"Analyzing project {project.ProjectId}");
foreach (var file in project.Files)
{
if (file.PrimaryProject == project)
{
file.Analyze();
}
}
UploadProject(project);
}
public ManagedProjectAnalyzer(
SemanticServices semanticServices,
RepoProject repoProject,
ProjectId projectId,
Lazy <Task <Solution> > lazySolution)
{
this.semanticServices = semanticServices;
ProjectId = projectId;
this.lazySolution = lazySolution;
var analyzedProject = new AnalyzedProject(repoProject.Repo.Name, repoProject.ProjectId);
ProjectContext = new AnalyzedProjectContext(analyzedProject);
}
public override void Initialize(Repo repo)
{
var dd = new Dictionary <string, RepoProject>();
foreach (var semanticDataDirectory in semanticDataDirectories)
{
var store = new CodexSemanticStore(semanticDataDirectory);
store.Load();
foreach (var project in store.Projects.List)
{
var repoProject = new RepoProject(project.Name, repo)
{
ProjectDirectory = project.Directory,
// $TODO;
//ProjectFile = projectFile
};
dd.Add(project.Name, repoProject);
repo.Projects.Add(repoProject);
}
foreach (var file in store.Files.List)
{
if (!m_fileToStoreMap.ContainsKey(file.Path))
{
RepoFile repoFile;
if (!repo.FilesByPath.TryGetValue(file.Path, out repoFile))
{
RepoProject project;
if (!dd.TryGetValue(store.Projects[file.Project].Name, out project))
{
project = repo.DefaultRepoProject;
}
repoFile = project.AddFile(file.Path);
}
m_fileToStoreMap[repoFile.RepoRelativePath] = file;
}
}
}
}
private void CreateMetadataFile(RepoProject project, string fileName, Func <XElement> elementFactory)
{
var metadataFileBuilder = elementFactory().CreateAnnotatedSourceBuilder(
new SourceFileInfo()
{
Path = GetMetadataFilePath(fileName),
Language = "xml",
}, Project.Id);
var repoFile = project.AddFile(
$@"\\Codex\ProjectMetadata\{project.ProjectId}\{metadataFileBuilder.SourceFile.Info.Path}",
metadataFileBuilder.SourceFile.Info.Path);
repoFile.InMemorySourceFileBuilder = metadataFileBuilder;
metadataFileBuilder.BoundSourceFile.ExcludeFromSearch = true;
repoFile.Analyze();
}
private static RepoFile AddDocumentToProject(RepoProject project, DocumentInfo document)
{
if (document.FilePath == null)
{
return(null);
}
string logicalPath = null;
if (!project.InProjectDirectory(document.FilePath))
{
logicalPath = GetLogicalPath(document);
if (logicalPath.Contains(":"))
{
logicalPath = null;
}
}
return(project.AddFile(document.FilePath, logicalPath));
}
protected static void UploadProject(RepoProject project, AnalyzedProject analyzedProject)
{
analyzedProject.ProjectKind = project.ProjectKind;
project.Repo.AnalysisServices.TaskDispatcher.QueueInvoke(() =>
project.Repo.AnalysisServices.AnalysisTarget.AddProjectAsync(project, analyzedProject), TaskType.Upload);
}
public virtual void UploadProject(RepoProject project)
{
AnalyzedProject analyzedProject = new AnalyzedProject(project.Repo.Name, project.ProjectId);
UploadProject(project, analyzedProject);
}
public override void Analyze(RepoProject project)
{
}
public override void UploadProject(RepoProject project)
{
}
public override void Analyze(RepoProject project)
{
base.Analyze(project);
}
