public List <string> GetCSCodeFiles(string projPath)
{
AnalyzerManager manager = new AnalyzerManager();
var pro = manager.GetProject(projPath);
var pro2 = pro.Load();
List <string> outP = new List <string>()
{
};
foreach (var item in pro2.Items)
{
if (item.ItemType == "Compile")
{
outP.Add(item.EvaluatedInclude);
}
}
return(outP);
}
public DependencyGraph Analyze(string projectPath, string framework = null)
{
var analyzerManager = new AnalyzerManager(new AnalyzerManagerOptions
{
LoggerFactory = _loggerFactory
});
if (string.IsNullOrWhiteSpace(projectPath))
{
throw new ArgumentException(nameof(projectPath));
}
if (!File.Exists(projectPath))
{
throw new ArgumentException("Project path does not exist.", nameof(projectPath));
}
var projectAnalyzer = analyzerManager.GetProject(projectPath);
return(CreateBuilder(projectAnalyzer, projectPath, null, framework).Build());
}
static void Main(string[] args)
{
var analyzerManager = new AnalyzerManager();
var projectAnalyzer = analyzerManager.GetProject(@"D:\workshop\ConsoleApp1\ConsoleApp1\ConsoleApp1.csproj");
var analyzerResults = projectAnalyzer.Build().First();
Console.WriteLine($"{analyzerResults.References.Length} references");
Console.WriteLine($"{analyzerResults.SourceFiles.Length} source files");
Console.WriteLine();
foreach (var file in analyzerResults.SourceFiles)
{
Console.WriteLine(file);
}
var workspace = projectAnalyzer.GetWorkspace();
var project = workspace.CurrentSolution.Projects.First();
var compilation = project.GetCompilationAsync().Result;
var diagnostics = compilation.GetDiagnostics();
foreach (var error in diagnostics.Where(l => l.Severity > DiagnosticSeverity.Hidden))
{
Console.WriteLine(error);
}
foreach (var syntaxTree in compilation.SyntaxTrees)
{
var root = (CompilationUnitSyntax)syntaxTree.GetRoot();
var text = root.GetText();
Console.WriteLine();
Console.WriteLine(Path.GetFileName(syntaxTree.FilePath));
Console.WriteLine(text.GetSubText(root.Span));
var semanticModel = compilation.GetSemanticModel(syntaxTree);
}
}
private AnalyzerResult Build(AnalyzerManager manager, Project project, string?tfm)
{
_console.Write(" -> Analyzing ");
_console.ForegroundColor = ConsoleColor.Cyan;
_console.Write(project.Name);
_console.ResetColor();
if (!string.IsNullOrWhiteSpace(tfm))
{
_console.ForegroundColor = ConsoleColor.DarkGray;
_console.Write(" (");
_console.Write(tfm);
_console.Write(")");
_console.ResetColor();
_console.WriteLine();
}
var projectAnalyzer = manager.GetProject(project.Path);
var results = (IEnumerable <AnalyzerResult>)projectAnalyzer.Build();
if (!string.IsNullOrWhiteSpace(tfm))
{
var closest = results.GetNearestFrameworkMoniker(tfm);
results = results.Where(p => p.TargetFramework.Equals(closest, StringComparison.OrdinalIgnoreCase));
}
var result = results.FirstOrDefault();
if (string.IsNullOrWhiteSpace(tfm))
{
_console.ForegroundColor = ConsoleColor.DarkGray;
_console.Write(" (");
_console.Write(result.TargetFramework);
_console.ForegroundColor = ConsoleColor.DarkGray;
_console.WriteLine(")");
_console.ResetColor();
}
return(result);
}
private Compilation AddProjectReferences(IExecutionContext context, List <ISymbol> symbols, Compilation compilation)
{
// Generate a single Workspace and add all of the projects to it
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(new AnalyzerManagerOptions
{
LogWriter = log
});
AdhocWorkspace workspace = new AdhocWorkspace();
IEnumerable <IFile> projectFiles = context.FileSystem.GetInputFiles(_projectGlobs)
.Where(x => x.Path.Extension == ".csproj" && x.Exists);
List <Project> projects = new List <Project>();
foreach (IFile projectFile in projectFiles)
{
Project project = workspace.CurrentSolution.Projects.FirstOrDefault(x => new FilePath(x.FilePath).Equals(projectFile.Path));
if (project != null)
{
Trace.Verbose($"Project {projectFile.Path.FullPath} was already in the workspace");
}
else
{
Trace.Verbose($"Creating workspace project for {projectFile.Path.FullPath}");
ProjectAnalyzer analyzer = manager.GetProject(projectFile.Path.FullPath);
if (context.Bool(CodeAnalysisKeys.OutputBuildLog))
{
analyzer.WithBinaryLog();
}
ReadWorkspace.CompileProjectAndTrace(analyzer, log);
project = analyzer.AddToWorkspace(workspace);
if (!project.Documents.Any())
{
Trace.Warning($"Project at {projectFile.Path.FullPath} contains no documents, which may be an error (check previous log output for any MSBuild warnings)");
}
}
projects.Add(project);
}
compilation = AddProjectReferences(projects, symbols, compilation);
return(compilation);
}
protected async Task <AnalyzerResult> DesignTimeBuild()
{
using (var operation = _log.OnEnterAndConfirmOnExit())
{
AnalyzerResult result;
var csProj = this.GetProjectFile();
var logWriter = new StringWriter();
using (await FileLock.TryCreateAsync(Directory))
{
var manager = new AnalyzerManager(new AnalyzerManagerOptions
{
LogWriter = logWriter
});
var analyzer = manager.GetProject(csProj.FullName);
analyzer.AddBinaryLogger(Path.Combine(Directory.FullName, DesignTimeBuildBinlogFileName));
var languageVersion = csProj.SuggestedLanguageVersion();
analyzer.SetGlobalProperty("langVersion", languageVersion);
result = analyzer.Build().Results.First();
}
DesignTimeBuildResult = result;
LastDesignTimeBuild = Clock.Current.Now();
if (result.Succeeded == false)
{
var logData = logWriter.ToString();
File.WriteAllText(
LastBuildErrorLogFile.FullName,
string.Join(Environment.NewLine, "Design Time Build Error", logData));
}
else if (LastBuildErrorLogFile.Exists)
{
LastBuildErrorLogFile.Delete();
}
operation.Succeed();
return(result);
}
}
static void Main(string[] args)
{
try
{
System.Runtime.Loader.AssemblyLoadContext.Default.Resolving += (ctx, name) =>
{
Console.WriteLine($"asm name={name}");
return(null);
};
// another workaround, read required assemblies before compile.
foreach (var dllname in new string[] { "NuGet.Versioning", "NuGet.Common", "NuGet.Frameworks" })
{
const string sdkdir = @"C:\Program Files\dotnet\sdk\2.1.300";
System.Runtime.Loader.AssemblyLoadContext.Default.LoadFromAssemblyPath(Path.Combine(sdkdir, $"{dllname}.dll"));
}
var manageropts = new AnalyzerManagerOptions();
manageropts.LogWriter = Console.Out;
manageropts.LoggerVerbosity = LoggerVerbosity.Normal;
var manager = new AnalyzerManager(manageropts);
var analyzer = manager.GetProject(args[0]);
var project = analyzer.Compile();
if (project != null)
{
foreach (var x in project.Items)
{
var meta = x.Metadata.Select(y => $"{y.Name}={y.EvaluatedValue}");
Console.WriteLine($"{x.ItemType},{string.Join("|", meta)}");
}
}
else
{
Console.WriteLine($"project instance is null");
}
}
catch (Exception e)
{
Console.WriteLine($"{e}");
}
}
public static async Task <Compilation> GetCompilationFromProject(string csprojPath, params string[] preprocessorSymbols)
{
var analyzerOptions = new AnalyzerManagerOptions();
// analyzerOptions.LogWriter = Console.Out;
var manager = new AnalyzerManager();
var projectAnalyzer = manager.GetProject(csprojPath); // addproj
// projectAnalyzer.AddBuildLogger(new Microsoft.Build.Logging.ConsoleLogger(Microsoft.Build.Framework.LoggerVerbosity.Minimal));
var workspace = manager.GetWorkspaceWithPreventBuildEvent();
workspace.WorkspaceFailed += WorkSpaceFailed;
var project = workspace.CurrentSolution.Projects.First();
project = project
.WithParseOptions((project.ParseOptions as CSharpParseOptions).WithPreprocessorSymbols(preprocessorSymbols))
.WithCompilationOptions((project.CompilationOptions as CSharpCompilationOptions).WithAllowUnsafe(true));
var compilation = await project.GetCompilationAsync().ConfigureAwait(false);
return(compilation);
}
public Task <IProjectInfo> ReadProjectAsync(string path, IProgress <string> progress)
{
return(Task.Run <IProjectInfo>(() =>
{
var analyzerManager = new AnalyzerManager();
// TODO: This should add debug symbols to the build, which we can then access
// via Cecil according to https://github.com/jbevain/cecil/wiki/Debug-symbols
analyzerManager.SetGlobalProperty("Configuration", "Debug");
var projectAnalyzer = analyzerManager.GetProject(path);
progress.Report($"Building {Path.GetFileName(path)}");
var analyzerResult = projectAnalyzer.Build(new EnvironmentOptions
{
DesignTime = false,
Restore = true
})
.First();
return new ProjectInfo(analyzerResult);
}));
}
private static async Task RunAsync(string projectPath, CancellationToken cancellationToken)
{
var converters = new ConverterBase[]
{
new MSTestToXUnitConverter(),
new TestAssertTrueOrFalseConverter(),
new AssertArgumentOrderConverter(),
};
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(projectPath);
Encoding s_utf8WithoutBom = new UTF8Encoding(false);
using (var workspace = analyzer.GetWorkspace())
{
var originalSolution = workspace.CurrentSolution;
var project = originalSolution.Projects.FirstOrDefault();
foreach (var converter in converters)
{
var newSolution = await converter.ProcessAsync(project, cancellationToken);
newSolution.GetChanges(originalSolution).GetProjectChanges().ToList().ForEach(proj =>
{
var changedDocumentIds = proj.GetChangedDocuments(true).ToList();
changedDocumentIds.ForEach(documentId =>
{
var document = newSolution.GetDocument(documentId);
var text = document.GetTextAsync();
using (var writer = new StreamWriter(document.FilePath, append: false, encoding: text.Result.Encoding ?? s_utf8WithoutBom))
{
text.Result.Write(writer);
}
});
});
//workspace.TryApplyChanges(project.Solution);
}
}
}
public async Task <Compilation> CompileAsync()
{
var manager = new AnalyzerManager();
var project = manager.GetProject(testProjectCsproj);
var workspace = new AdhocWorkspace();
var roslynProject = project.AddToWorkspace(workspace);
var compilation = await roslynProject.GetCompilationAsync();
var diagnostics = compilation.GetDiagnostics();
foreach (var diagnostic in diagnostics)
{
testContext.WriteLine(diagnostic.GetMessage());
}
if (diagnostics.Any(d => d.Severity == DiagnosticSeverity.Error))
{
Assert.Fail("Test project build failed!");
}
return(compilation);
}
public ConfigurationReader(string configurationProjectDirectory)
{
if (!Directory.Exists(configurationProjectDirectory))
{
throw new ArgumentException($"Directory {configurationProjectDirectory} does not exist");
}
var csProjPath = Directory.EnumerateFiles(configurationProjectDirectory, "*.csproj").SingleOrDefault();
if (string.IsNullOrEmpty(csProjPath))
{
throw new ArgumentException($"Could not find csproj file in {configurationProjectDirectory} directory");
}
var manager = new AnalyzerManager();
var analyzer = manager.GetProject(csProjPath);
analyzer.SetGlobalProperty("IsRunningHotPathAllocationAnalyzerConfiguration", "true");
var workspace = new AdhocWorkspace();
_configurationProject = analyzer.AddToWorkspace(workspace);
}
public void CompilesProject(EnvironmentPreference preference, string solutionPath, string projectPath)
{
// Given
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(solutionPath, new AnalyzerManagerOptions
{
LogWriter = log,
LoggerVerbosity = Verbosity
});
ProjectAnalyzer analyzer = manager.GetProject(projectPath);
EnvironmentOptions options = new EnvironmentOptions
{
Preference = preference
};
// Set some enviornment variables to make it seem like we're not in a CI build
// Sometimes this messes up libraries like SourceLink since we're building as part of a test and not for CI
options.EnvironmentVariables.Add("APPVEYOR", "False");
options.EnvironmentVariables.Add("ContinuousIntegrationBuild", null);
options.EnvironmentVariables.Add("CI", "False");
options.EnvironmentVariables.Add("CI_LINUX", "False");
options.EnvironmentVariables.Add("CI_WINDOWS", "False");
// When
DeleteProjectDirectory(analyzer.ProjectFile.Path, "obj");
DeleteProjectDirectory(analyzer.ProjectFile.Path, "bin");
analyzer.IgnoreFaultyImports = false;
if (BinaryLog)
{
analyzer.AddBinaryLogger($@"E:\Temp\{Path.GetFileNameWithoutExtension(solutionPath)}.{Path.GetFileNameWithoutExtension(analyzer.ProjectFile.Path)}.core.binlog");
}
AnalyzerResults results = analyzer.Build(options);
// Then
results.Count.ShouldBeGreaterThan(0, log.ToString());
results.ShouldAllBe(x => x.OverallSuccess, log.ToString());
}
/// <summary>
/// Creates the project info from the msBuild project
/// </summary>
/// <param name="msBuildProj">The ms Build project</param>
/// <returns>The project info</returns>
protected override ProjectInfo CreateProjectInfo(MsBuild.Project msBuildProj)
{
AnalyzerManager mgr = new AnalyzerManager();
ProjectAnalyzer projAnalyzer = mgr.GetProject(ProjectPath);
AdhocWorkspace workspace = projAnalyzer.GetWorkspace(true); // This doesn't seems to work either way
Project proj = workspace.CurrentSolution.Projects.First();
StringBuilder builder = new StringBuilder();
IEnumerable <MsBuild.ProjectItem> compile = msBuildProj.Items.Where(itm => itm.ItemType == "Compile");
foreach (MsBuild.ProjectItem item in compile)
{
builder.Append($"{item.EvaluatedInclude} ");
}
// /out provides a name
builder.Append($"/out:{new FileInfo(msBuildProj.FullPath).Name} ");
// target: TODO: What does this do?
builder.Append("/target:library ");
ProjectInfo info = CommandLineProject.CreateProjectInfo(
proj.Name,
LanguageNames.CSharp,
CommandLineParser.SplitCommandLineIntoArguments(builder.ToString(), true),
msBuildProj.DirectoryPath,
null);
// Add the references found by buildalyzer
info = info.WithFilePath(msBuildProj.FullPath)
.WithMetadataReferences(proj.MetadataReferences)
.WithAnalyzerReferences(proj.AnalyzerReferences);
return(info);
}
private static void RunGeneration(string[] args, string projectPath)
{
AnalyzerManager mgr = new AnalyzerManager();
IProjectAnalyzer projAnalyzer = mgr.GetProject(projectPath);
using (Workspace workspace = projAnalyzer.GetWorkspace(true))
{
ProjectId mainProjId = workspace.CurrentSolution.Projects
.Where(pr => pr.FilePath == projectPath).FirstOrDefault()?.Id;
ProjectParser parser = new ProjectParser(workspace, mainProjId);
ScriptGenEngine engine = new ScriptGenEngine();
var result = engine.GenerateScripts(new ScriptGenerationParameters()
{
ProjectPath = projectPath,
TypeIterator = parser,
Force = args.HasSwitch(ForceSwitch)
});
if (!result.Success)
{
Console.WriteLine(result.ErrorMessage);
}
}
}
static async Task Main(string[] args)
{
var manager = new AnalyzerManager();
var analyzer = manager.GetProject("tests/MyApp1/MyApp1.csproj");
var rs = analyzer.GetWorkspace();
var workspace = new AdhocWorkspace();
analyzer.AddToWorkspace(workspace);
var project = workspace.CurrentSolution.Projects.First();
var docs = project.Documents;
foreach (var item in docs)
{
Console.WriteLine(item.FilePath);
}
var deps = project.MetadataReferences;
foreach (var item in deps)
{
Console.WriteLine(item.Display);
}
}
private async Task OnExecute()
{
var logger = new Logger();
// Load C# project
var manager = new AnalyzerManager();
var analyzer = manager.GetProject(Project);
var workspace = analyzer.GetWorkspace();
var project = workspace.CurrentSolution.Projects.First();
// Code generation
var translator = new Translator();
var generator = new Generator(translator, logger)
{
PythonDir = this.PythonDir
};
var newProject = await generator.Generate(project);
// Save project changes
// NB : This should work to save changes? Maybe isn't implemented with Buildalyzer?
// bool success = workspace.TryApplyChanges(newProject.Solution);
var projectChanges = newProject.GetChanges(project);
foreach (var changedDocumentId in projectChanges.GetChangedDocuments())
{
var document = newProject.GetDocument(changedDocumentId);
var documentRoot = await document.GetSyntaxRootAsync();
var code = documentRoot.ToFullString();
File.WriteAllText(document.FilePath, code);
}
}
static IEnumerable <string> CreateJsonRefList()
{
var projPath = Path.Combine(Helper.ProjectFolder, "src", "ReamQuery.Server", "ReamQuery.Server.csproj");
Console.WriteLine("Project file: {0} (exists: {1})", projPath, File.Exists(projPath));
var lf = new LoggerFactory();
lf.AddConsole();
var manager = new AnalyzerManager(lf, LoggerVerbosity.Minimal);
var analyzer = manager.GetProject(projPath);
analyzer.Load();
var refs = analyzer.GetReferences();
if (refs.Count() != refs.Distinct().Count())
{
throw new InvalidOperationException("Unexpected duplicates");
}
var json = JsonConvert.SerializeObject(refs.Select(x => Path.GetFileName(x)), Formatting.Indented);
var jsonPath = Path.Combine(Helper.ProjectFolder, "src", "ReamQuery.Resources", "ReferenceList.json");
File.WriteAllText(jsonPath, json);
return(refs);
}
private static async Task PerformMigration(CliOptions options)
{
if (string.IsNullOrEmpty(options.SolutionPath) &&
string.IsNullOrEmpty(options.MigrationPath))
{
Console.WriteLine("Either project or sulution path must be provided.");
return;
}
var workspace = new AdhocWorkspace();
if (!string.IsNullOrEmpty(options.SolutionPath))
{
Console.WriteLine("Loading solution:");
var manager = new AnalyzerManager(options.SolutionPath);
foreach (var p in manager.Projects.Values)
{
Console.WriteLine($"Loading project: {p.ProjectFile.Path}");
p.AddToWorkspace(workspace);
}
}
else
{
Console.WriteLine("Loading project");
var manager = new AnalyzerManager();
manager.GetProject(options.ProjectPath).AddToWorkspace(workspace);
}
Console.WriteLine("Loading migration file");
var migration = MigrationLoader.FromPath(options.MigrationPath);
var timer = Stopwatch.StartNew();
await Task.WhenAll(workspace.CurrentSolution.Projects.Select(async project =>
{
Console.WriteLine($"Migrating project {project.Name}");
var compilation = (CSharpCompilation)await project.GetCompilationAsync();
await Task.WhenAll(compilation.SyntaxTrees.Select(async tree =>
{
var annotatedTree = tree.WithRootAndOptions(
new AnnotationVisitor().Visit(await tree.GetRootAsync()),
tree.Options);
compilation = compilation.ReplaceSyntaxTree(tree, annotatedTree);
if (options.Verbose)
{
Console.WriteLine("Running migration on " + tree.FilePath);
}
var context = new MigrationContext();
context.Populate(compilation, annotatedTree);
var ast = migration.Apply(annotatedTree, context);
if (ast != annotatedTree)
{
await File.WriteAllTextAsync(tree.FilePath, ast.ToString());
}
}));
}));
Console.WriteLine("Migration took: " + timer.Elapsed);
}
static async Task Main(string[] args)
{
// Buildalyzerのルート
var manager = new AnalyzerManager();
// slnを指定してまるっと持ってくるでもいいんですが、とりあえずcsproj単品で並べてみた。
// 解析対象となる対象のプロジェクトと、参照としてのUniRxのプロジェクトを登録(Getすると同時に登録も行われるという仕様……)
manager.GetProject(@"C:\***\UniRx.csproj");
manager.GetProject(@"C:\***\UniRx.Async.csproj");
manager.GetProject(@"C:\***\Assembly-CSharp.csproj");
// 登録されたプロジェクト群からAdhocWorkspaceを作成
var workspace = manager.GetWorkspace();
var targetProject = workspace.CurrentSolution.Projects.First(x => x.Name == "Assembly-CSharp");
// コンパイル結果みたいなのを取得
var compilation = await targetProject.GetCompilationAsync();
// 比較対象の型シンボルをCompilationから持ってくる
var observableSymbol = compilation.GetTypeByMetadataName("UniRx.Observable");
// 収集
var methods = new List <IMethodSymbol>();
foreach (var tree in compilation.SyntaxTrees)
{
// Syntax -> Symbol変換するためのModelの取得
var semanticModel = compilation.GetSemanticModel(tree);
// シンタックスツリーからメソッド呼び出しだけを抜き出し
var invocationExpressions = tree.GetRoot()
.DescendantNodes()
.OfType <InvocationExpressionSyntax>();
foreach (var expr in invocationExpressions)
{
// その中からUniRx.Observableに属するメソッドのみを抽出
var methodSymbol = semanticModel.GetSymbolInfo(expr).Symbol as IMethodSymbol;
if (methodSymbol?.ContainingType == observableSymbol)
{
methods.Add(methodSymbol);
}
}
}
// 解析
Console.WriteLine("## TotalCount:" + methods.Count);
var grouping = methods
.Select(x => x.OriginalDefinition) // Foo -> Fooへ変換
.Select(x => x.Name) // 今回はメソッド名だけ取る(オーバーロードの違いは無視)
.GroupBy(x => x)
.OrderByDescending(x => x.Count())
.Select(x => new { MethodName = x.Key, Count = x.Count() })
.ToArray();
// マークダウンの表で出力
Console.WriteLine("| メソッド名| 呼び出し数 |");
Console.WriteLine("| --- | --- |");
foreach (var item in grouping)
{
Console.WriteLine($"| {item.MethodName} | {item.Count} |");
}
}
public DependencyGraph Analyze(string projectPath, string framework = null)
{
if (string.IsNullOrWhiteSpace(projectPath))
{
throw new ArgumentException(nameof(projectPath));
}
if (!File.Exists(projectPath))
{
throw new ArgumentException("Project path does not exist.", nameof(projectPath));
}
var analyzerManager = new AnalyzerManager(new AnalyzerManagerOptions
{
LoggerFactory = _loggerFactory
});
var projectAnalyzer = analyzerManager.GetProject(projectPath);
var analyzeResults = string.IsNullOrEmpty(framework) ?
projectAnalyzer.Build() : projectAnalyzer.Build(framework);
var analyzerResult = string.IsNullOrEmpty(framework) ?
analyzeResults.FirstOrDefault() : analyzeResults[framework];
if (analyzerResult == null)
{
// Todo: Something went wrong, log and return better exception.
throw new InvalidOperationException("Unable to load project.");
}
if (!analyzerResult.IsNetSdkProject())
{
// Todo: Support "legacy" projects in the future.
throw new InvalidOperationException("Unable to load project.");
}
var projectAssetsFilePath = analyzerResult.GetProjectAssetsFilePath();
if (!File.Exists(projectAssetsFilePath))
{
// Todo: Make sure this exists in future
throw new InvalidOperationException($"{projectAssetsFilePath} not found. Please run 'dotnet restore'");
}
var lockFile = new LockFileFormat().Read(projectAssetsFilePath);
var targetFramework = analyzerResult.GetTargetFramework();
var libraries = lockFile.Targets.Single(x => x.TargetFramework == targetFramework)
.Libraries.Where(x => x.IsPackage()).ToList();
var projectNode = new ProjectReferenceNode(projectPath);
var builder = new DependencyGraph.Builder(projectNode);
var libraryNodes = new Dictionary <string, PackageReferenceNode>(StringComparer.OrdinalIgnoreCase);
foreach (var library in libraries)
{
var libraryNode = library.ToNode();
builder.WithNode(libraryNode);
libraryNodes.Add(libraryNode.PackageId, libraryNode);
if (library.FrameworkAssemblies.Count > 0)
{
var assemblyNodes = library.FrameworkAssemblies
.Select(x => new AssemblyReferenceNode($"{x}.dll"));
builder.WithNodes(assemblyNodes);
builder.WithEdges(assemblyNodes
.Select(x => new Edge(libraryNode, x)));
}
if (library.RuntimeAssemblies.Count > 0)
{
var assemblyNodes = library.RuntimeAssemblies
.Select(x => new AssemblyReferenceNode(Path.GetFileName(x.Path)))
.Where(x => x.Id != "_._");
if (assemblyNodes.Any())
{
builder.WithNodes(assemblyNodes);
builder.WithEdges(assemblyNodes
.Select(x => new Edge(libraryNode, x)));
}
}
//if (library.CompileTimeAssemblies.Count > 0)
//{
// var assemblyNodes = library.CompileTimeAssemblies
// .Select(x => new AssemblyReferenceNode(Path.GetFileName(x.Path)));
// builder.WithNodes(assemblyNodes);
// builder.WithEdges(assemblyNodes
// .Select(x => new Edge(libraryNode, x)));
//}
}
foreach (var library in libraries)
{
var libraryNode = library.ToNode();
if (library.Dependencies.Count > 0)
{
builder.WithEdges(library.Dependencies
.Select(x => new Edge(libraryNode, libraryNodes[x.Id], x.VersionRange.ToString())));
}
}
builder.WithEdges(analyzerResult.GetItems("PackageReference")
.Select(x => new Edge(projectNode, libraryNodes[x.ItemSpec], x.Metadata["Version"])));
var references = analyzerResult.References//GetItems("Reference")
.Select(x => new AssemblyReferenceNode(Path.GetFileName(x)));
builder.WithNodes(references);
builder.WithEdges(references.Select(x => new Edge(projectNode, x)));
return(builder.Build());
}
public void Build()
{
/* Uncomment the below code to debug issues with msbuild */
/*var writer = new StreamWriter(Console.OpenStandardOutput());
* writer.AutoFlush = true;
*
* Console.SetOut(writer);
* Console.SetError(writer);*/
if (IsSolutionFile())
{
Logger.LogInformation("Loading the Workspace (Solution): " + WorkspacePath);
AnalyzerManager analyzerManager = new AnalyzerManager(WorkspacePath,
new AnalyzerManagerOptions
{
LogWriter = _writer
});
Logger.LogInformation("Loading the Solution Done: " + WorkspacePath);
// AnalyzerManager builds the projects based on their dependencies
// After this, code does not depend on Buildalyzer
BuildSolution(analyzerManager);
}
else
{
AnalyzerManager analyzerManager = new AnalyzerManager(new AnalyzerManagerOptions
{
LogWriter = _writer
});
var dict = new Dictionary <Guid, IAnalyzerResult>();
using (AdhocWorkspace workspace = new AdhocWorkspace())
{
Queue <string> queue = new Queue <string>();
ISet <string> existing = new HashSet <string>();
queue.Enqueue(WorkspacePath);
existing.Add(WorkspacePath);
/*
* We need to resolve all the project dependencies to avoid compilation errors.
* If we have compilation errors, we might miss some of the semantic values.
*/
while (queue.Count > 0)
{
var path = queue.Dequeue();
Logger.LogInformation("Building: " + path);
IProjectAnalyzer projectAnalyzer = analyzerManager.GetProject(path);
if (!TryGetRequiresNetFramework(projectAnalyzer.ProjectFile, out bool requiresNetFramework))
{
continue;
}
IAnalyzerResults analyzerResults = projectAnalyzer.Build(GetEnvironmentOptions(requiresNetFramework, projectAnalyzer.ProjectFile.ToolsVersion));
IAnalyzerResult analyzerResult = analyzerResults.First();
if (analyzerResult == null)
{
FailedProjects.Add(new ProjectAnalysisResult()
{
ProjectAnalyzer = projectAnalyzer
});
}
dict[analyzerResult.ProjectGuid] = analyzerResult;
analyzerResult.AddToWorkspace(workspace);
foreach (var pref in analyzerResult.ProjectReferences)
{
if (!existing.Contains(pref))
{
existing.Add(pref);
queue.Enqueue(pref);
}
}
}
foreach (var project in workspace.CurrentSolution.Projects)
{
try
{
var result = dict[project.Id.Id];
var projectAnalyzer = analyzerManager.Projects.Values.FirstOrDefault(p =>
p.ProjectGuid.Equals(project.Id.Id));
Projects.Add(new ProjectAnalysisResult()
{
Project = project,
AnalyzerResult = result,
ProjectAnalyzer = projectAnalyzer
});
}
catch (Exception ex)
{
Logger.LogDebug(ex.StackTrace);
}
}
}
}
Logger.LogDebug(_sb.ToString());
_writer.Flush();
_writer.Close();
ProcessLog(_writer.ToString());
}
public List <ClassFileInfo> Deep()
{
List <ClassFileInfo> result = new List <ClassFileInfo>();
var solutionFilePath = BuildWorkspaceHelper.GetRelativeWorkspacePath("Syinpo.Model\\Syinpo.Model.csproj");
{
//using( var work = MSBuildWorkspace.Create() ) {
// var project = work.OpenProjectAsync( solutionFilePath ).Result;
// var documents = project.Documents.Where( w => w.Name.EndsWith( ".cs" ) ).ToList();
//}
}
AnalyzerManager manager = new AnalyzerManager();
var analyzer = manager.GetProject(solutionFilePath);
AdhocWorkspace workspace = analyzer.GetWorkspace();
var project = workspace.CurrentSolution.Projects.First();
var documents = project.Documents.Where(w => w.Name.EndsWith(".cs")).ToList();
foreach (var document in documents)
{
string fileName = document.Name;
string filePath = document.FilePath;
var classes = document.GetSyntaxRootAsync().Result.DescendantNodes().OfType <ClassDeclarationSyntax>();
var classes2 = document.GetSyntaxRootAsync().Result.DescendantNodes().ToList().OfType <EnumDeclarationSyntax>();
if (classes.Any())
{
foreach (var cl in classes)
{
NamespaceDeclarationSyntax namespaceDeclarationSyntax = null;
if (!SyntaxNodeHelper.TryGetParentSyntax(cl, out namespaceDeclarationSyntax))
{
continue;
}
var namespaceName = namespaceDeclarationSyntax.Name.ToString();
var fullClassName = namespaceName + "." + cl.Identifier.ToString();
var keys = document.Folders.ToList();
keys.Add(fileName);
result.Add(new ClassFileInfo {
FileName = fileName,
FilePath = filePath,
ClassName = cl.Identifier.ToString(),
FullClassName = fullClassName,
Key = string.Join(@"/", keys.ToArray())
});
}
}
if (classes2.Any())
{
foreach (var cl in classes2)
{
NamespaceDeclarationSyntax namespaceDeclarationSyntax = null;
if (!SyntaxNodeHelper.TryGetParentSyntax(cl, out namespaceDeclarationSyntax))
{
continue;
}
var namespaceName = namespaceDeclarationSyntax.Name.ToString();
var fullClassName = namespaceName + "." + cl.Identifier.ToString();
var keys = document.Folders.ToList();
keys.Add(fileName);
result.Add(new ClassFileInfo {
FileName = fileName,
FilePath = filePath,
ClassName = cl.Identifier.ToString(),
FullClassName = fullClassName,
Key = string.Join(@"/", keys.ToArray())
});
}
}
#region Old
if (false)
{
SourceText text = document.GetTextAsync().Result;
var span = TextSpan.FromBounds(0, text.Length);
IEnumerable <ClassifiedSpan> classifiedSpans = null;
try {
classifiedSpans = Classifier.GetClassifiedSpansAsync(document, span).Result;
IEnumerable <Range> ranges = classifiedSpans.Select(classifiedSpan => new Range(classifiedSpan, text.GetSubText(classifiedSpan.TextSpan).ToString()));
// var classes = ranges.Where(w => w.ClassificationType == "class name").ToList();
}
catch (Exception ex) {
throw new Exception("Exception during Classification of document: " + document.FilePath);
}
}
#endregion
}
return(result);
}
private static Project Create(AnalyzerManager manager, Options options, string projectFile)
{
var analyzer = manager.GetProject(projectFile);
var msBuildProject = analyzer.Load();
var assemblyFile = msBuildProject.GetItems("IntermediateAssembly").FirstOrDefault()?.EvaluatedInclude;
if (assemblyFile == null)
{
// Not all projects may produce an assembly
return(null);
}
var projectDirectory = Path.GetDirectoryName(projectFile);
var assemblyFileFullPath = Path.GetFullPath(Path.Combine(projectDirectory, assemblyFile));
if (!File.Exists(assemblyFileFullPath))
{
// Can't analyze this project since it hasn't been built
Console.WriteLine($"Assembly did not exist. Ensure you've previously built it. Assembly: {assemblyFileFullPath}");
return(null);
}
var assembly = LoadAssembly(assemblyFileFullPath);
if (assembly == null)
{
// Can't analyze this project since we couldn't load its assembly
Console.WriteLine($"Assembly could not be loaded. Assembly: {assemblyFileFullPath}");
return(null);
}
var assemblyReferences = assembly
.GetReferencedAssemblies()
.Select(name => name.Name)
.ToHashSet(StringComparer.OrdinalIgnoreCase);
var references = msBuildProject
.GetItems("Reference")
.Select(reference => reference.EvaluatedInclude)
.ToList();
var projectReferences = msBuildProject
.GetItems("ProjectReference")
.Select(reference => reference.EvaluatedInclude)
.Select(projectReference => GetProject(manager, options, Path.GetFullPath(Path.Combine(projectDirectory, projectReference))))
.Where(dependency => dependency != null)
.ToList();
var packageReferences = msBuildProject
.GetItems("PackageReference")
.Select(reference => reference.EvaluatedInclude)
.ToList();
// Certain project types may require references simply to copy them to the output folder to satisfy transitive dependencies.
if (NeedsTransitiveAssemblyReferences(msBuildProject))
{
projectReferences.ForEach(projectReference => assemblyReferences.UnionWith(projectReference.AssemblyReferences));
}
// Only bother doing a design-time build if there is a reason to
var packageAssemblies = new Dictionary <string, List <string> >(StringComparer.OrdinalIgnoreCase);
if (packageReferences.Count > 0)
{
if (options.MsBuildBinlog)
{
analyzer.WithBinaryLog();
}
var msBuildCompiledProject = analyzer.Compile();
var packageParents = msBuildCompiledProject.GetItems("_ActiveTFMPackageDependencies")
.Where(package => !string.IsNullOrEmpty(package.GetMetadataValue("ParentPackage")))
.GroupBy(
package =>
{
var packageIdentity = package.EvaluatedInclude;
return(packageIdentity.Substring(0, packageIdentity.IndexOf('/')));
},
package =>
{
var parentPackageIdentity = package.GetMetadataValue("ParentPackage");
return(parentPackageIdentity.Substring(0, parentPackageIdentity.IndexOf('/')));
},
StringComparer.OrdinalIgnoreCase)
.ToDictionary(group => group.Key, group => group.ToList());
var resolvedPackageReferences = msBuildCompiledProject.GetItems("Reference")
.Where(reference => reference.GetMetadataValue("NuGetSourceType").Equals("Package", StringComparison.OrdinalIgnoreCase));
foreach (var resolvedPackageReference in resolvedPackageReferences)
{
var assemblyName = Path.GetFileNameWithoutExtension(resolvedPackageReference.EvaluatedInclude);
// Add the assembly to the containing package and all parent packages.
var seenParents = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
var queue = new Queue <string>();
queue.Enqueue(resolvedPackageReference.GetMetadataValue("NuGetPackageId"));
while (queue.Count > 0)
{
var packageId = queue.Dequeue();
if (!packageAssemblies.TryGetValue(packageId, out var assemblies))
{
assemblies = new List <string>();
packageAssemblies.Add(packageId, assemblies);
}
assemblies.Add(assemblyName);
if (packageParents.TryGetValue(packageId, out var parents))
{
foreach (var parent in parents)
{
if (seenParents.Add(parent))
{
queue.Enqueue(parent);
}
}
}
}
}
}
return(new Project
{
AssemblyName = assembly.GetName().Name,
AssemblyReferences = assemblyReferences,
References = references,
ProjectReferences = projectReferences,
PackageReferences = packageReferences,
PackageAssemblies = packageAssemblies,
});
}
public void AddProject(string projectPath)
{
var projectAnalyzer = AnalyzerManager.GetProject(projectPath);
projectAnalyzer.AddToWorkspace(Workspace, addProjectReferences: true);
}
public Task <int> OnExecuteAsync(CommandLineApplication app, CancellationToken cancellationToken)
{
bool isMSBuildFile;
var path = ProjectPath;
if (path == null)
{
path = Directory.GetCurrentDirectory();
var projectFiles = Directory.EnumerateFiles(path, "*", SearchOption.TopDirectoryOnly)
.Where(p => s_projectExtensionFilter.Contains(Path.GetExtension(p)))
.Take(2)
.ToArray();
if (projectFiles.Length == 1)
{
path = projectFiles[0];
isMSBuildFile = true;
}
else
{
isMSBuildFile = false;
}
}
else
{
path = Path.GetFullPath(path);
isMSBuildFile = !Directory.Exists(path);
}
IEnumerable <string> filePaths;
if (isMSBuildFile)
{
var originalWorkingDirectory = Environment.CurrentDirectory;
Environment.CurrentDirectory = Path.GetDirectoryName(path) !;
try
{
// https://daveaglick.com/posts/running-a-design-time-build-with-msbuild-apis
var analyzerManager = new AnalyzerManager();
var project = analyzerManager.GetProject(path);
var environmentOptions = new EnvironmentOptions();
if (Configuration != null)
{
environmentOptions.GlobalProperties["Configuration"] = Configuration;
}
Array.ForEach(RemainingArguments, arg => environmentOptions.Arguments.Add(arg));
IAnalyzerResult?analyzerResult;
if (TargetFramework != null)
{
var buildEnvironment = project.EnvironmentFactory.GetBuildEnvironment(TargetFramework, environmentOptions);
var analyzerResults = project.Build(buildEnvironment);
analyzerResult = analyzerResults?.FirstOrDefault(result => result.TargetFramework == TargetFramework);
if (analyzerResult == null)
{
throw new CommandException($"Unable to load MSBuild file \"{path}\" using target framework '{TargetFramework}'.");
}
}
else
{
var buildEnvironment = project.EnvironmentFactory.GetBuildEnvironment(environmentOptions);
var analyzerResults = project.Build(buildEnvironment);
analyzerResult = analyzerResults?.FirstOrDefault();
if (analyzerResult == null)
{
throw new CommandException($"Unable to load MSBuild file \"{path}\".");
}
}
var basePath = Path.GetDirectoryName(path) !;
if (!analyzerResult.Items.TryGetValue("Compile", out var compileItems))
{
compileItems = Array.Empty <ProjectItem>();
}
if (!analyzerResult.Items.TryGetValue("Content", out var contentItems))
{
contentItems = Array.Empty <ProjectItem>();
}
var projectItems = compileItems.Where(projectItem => s_compileExtensionFilter.Contains(Path.GetExtension(projectItem.ItemSpec)))
.Concat(contentItems.Where(projectItem => s_contentExtensionFilter.Contains(Path.GetExtension(projectItem.ItemSpec))));
if (!IncludeLinks)
{
projectItems = projectItems.Where(projectItem => !projectItem.Metadata.Keys.Contains("Link"));
}
filePaths = projectItems
.Select(projectItem => Path.GetFullPath(Path.Combine(basePath, projectItem.ItemSpec)));
}
finally
{
Environment.CurrentDirectory = originalWorkingDirectory;
}
}
else
{
filePaths = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
.Where(p => s_extensionFilter.Contains(Path.GetExtension(p)));
}
foreach (var filePath in filePaths)
{
_context.Console.WriteLine(filePath);
}
return(Task.FromResult(0));
}
public static async Task <Compilation> GetCompilationFromProject(string csprojPath, int verbosityLevel,
Dictionary <string, string> additionalProperties,
IEnumerable <string> conditionalSymbols)
{
conditionalSymbols = conditionalSymbols != null?
conditionalSymbols.Where(x => !string.IsNullOrEmpty(x)).ToArray()
:
Enumerable.Empty <string>();
// f*****g workaround of resolve reference...
var externalReferences = new List <PortableExecutableReference>();
{
var locations = new List <string>();
locations.Add(typeof(object).Assembly.Location); // mscorlib
locations.Add(typeof(System.Linq.Enumerable).Assembly.Location); // core
var xElem = XElement.Load(csprojPath);
var ns = xElem.Name.Namespace;
var csProjRoot = Path.GetDirectoryName(csprojPath);
var framworkRoot = Path.GetDirectoryName(typeof(object).Assembly.Location);
foreach (var item in xElem.Descendants(ns + "Reference"))
{
var hintPath = item.Element(ns + "HintPath")?.Value;
if (hintPath == null)
{
var path = Path.Combine(framworkRoot, item.Attribute("Include").Value + ".dll");
locations.Add(path);
}
else
{
locations.Add(Path.Combine(csProjRoot, hintPath));
}
}
foreach (var item in locations.Distinct())
{
if (File.Exists(item))
{
externalReferences.Add(MetadataReference.CreateFromFile(item));
}
}
}
EnvironmentHelper.Setup();
var analyzerOptions = new AnalyzerManagerOptions();
if (verbosityLevel > 0)
{
analyzerOptions.LogWriter = Console.Out;
}
var manager = new AnalyzerManager(analyzerOptions);
var projectAnalyzer = manager.GetProject(csprojPath);
projectAnalyzer.AddBuildLogger(new Microsoft.Build.Logging.ConsoleLogger(verbosityLevel.ToLoggerVerbosity()));
var buildopts = new EnvironmentOptions();
if (additionalProperties != null)
{
foreach (var kv in additionalProperties)
{
buildopts.GlobalProperties[kv.Key] = kv.Value;
projectAnalyzer.SetGlobalProperty(kv.Key, kv.Value);
}
}
if (conditionalSymbols.Any())
{
buildopts.GlobalProperties["DefineConstants"] = string.Join("%3b", conditionalSymbols);
}
var analyzerResults = projectAnalyzer.Build(buildopts);
var analyzerResult = analyzerResults.FirstOrDefault(x => x.Succeeded);
if (analyzerResult == null)
{
throw new Exception("no succeeded analyzer result found");
}
var ws = new AdhocWorkspace();
var project = analyzerResult.AddToWorkspace(ws);
var parseopts = project.ParseOptions as CSharpParseOptions;
if (parseopts != null)
{
var symbols = analyzerResult.Properties.ContainsKey("DefineConstants") ?
conditionalSymbols.Concat(
analyzerResult.Properties["DefineConstants"].Split(';')
).OrderBy(x => x).Distinct()
:
conditionalSymbols
;
project = project.WithParseOptions(parseopts.WithPreprocessorSymbols(symbols));
}
var compilation = await project.GetCompilationAsync().ConfigureAwait(false);
return(compilation);
}
