private Compilation AddSolutionReferences(IExecutionContext context, List <ISymbol> symbols, Compilation compilation)
{
IEnumerable <IFile> solutionFiles = context.FileSystem.GetInputFiles(_solutionGlobs)
.Where(x => x.Path.Extension == ".sln" && x.Exists);
foreach (IFile solutionFile in solutionFiles)
{
Trace.Verbose($"Creating workspace solution for {solutionFile.Path.FullPath}");
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(
solutionFile.Path.FullPath,
new AnalyzerManagerOptions
{
LogWriter = log
});
foreach (ProjectAnalyzer analyzer in manager.Projects.Values)
{
if (context.Bool(CodeAnalysisKeys.OutputBuildLog))
{
analyzer.WithBinaryLog();
}
ReadWorkspace.CompileProjectAndTrace(analyzer, log);
}
Workspace workspace = manager.GetWorkspace();
compilation = AddProjectReferences(workspace.CurrentSolution.Projects, symbols, compilation);
}
return(compilation);
}
public static async Task GoAsync(string[] args)
{
//.NET core csprojects are not supported all that well.
// https://github.com/dotnet/roslyn/issues/21660 :sadpanda:
// Use Buildalyzer to get a workspace from the solution.
var analyzer = new AnalyzerManager(Path.Combine(Program.InputDirPath, "Elasticsearch.DotNetCoreOnly.sln"));
var workspace = analyzer.GetWorkspace();
workspace.WorkspaceFailed += (s, e) =>
{
Console.Error.WriteLine(e.Diagnostic.Message);
};
// Buildalyzer, similar to MsBuildWorkspace with the new csproj file format, does
// not pick up source documents in the project directory. Manually add them
AddDocumentsToWorkspace(workspace);
var projects = workspace.CurrentSolution.Projects
.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
foreach (var file in GetDocumentFiles(projects).SelectMany(s => s))
{
await file.SaveToDocumentationFolderAsync();
}
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Documentation generated.");
Console.ResetColor();
if (Debugger.IsAttached)
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
static async Task Main(string[] args)
{
var solutionFilePath = args[0];
var manager = new AnalyzerManager(solutionFilePath);
var workspace = manager.GetWorkspace();
var builder = new Graph.Builder();
foreach (var project in workspace.CurrentSolution.Projects)
{
Console.WriteLine(project.FilePath);
foreach (var file in project.Documents)
{
builder.AddDocument(new Uri(file.FilePath));
// var symbols = await (new DocumentSymbolProvider()).GetCodeElementsAsync(file);
// foreach (var symbol in symbols)
// {
// Console.WriteLine(symbol);
// }
}
}
Console.WriteLine(builder.Build().ToString());
}
static void Main(string[] args)
{
var path = Environment.CurrentDirectory + "/../Pinger/Pinger.csproj";
path = Path.GetFullPath(path);
AnalyzerManager manager = new AnalyzerManager();
manager.GetProject(path);
Console.WriteLine("Starting");
var workspace = manager.GetWorkspace();
var project = workspace.CurrentSolution.Projects.Single();
var compilation = project.GetCompilationAsync().GetAwaiter().GetResult();
var isFound = compilation.ContainsSymbolsWithName(name => name == "Program", SymbolFilter.All);
Console.WriteLine(isFound);
foreach (var reference in project.Documents)
{
Console.WriteLine(reference.FilePath);
}
Console.WriteLine("Go");
}
private static async Task RunFormatItemAsync(IFormattingEngine engine, string item, string language, CancellationToken cancellationToken)
{
Console.WriteLine(Path.GetFileName(item));
string extension = Path.GetExtension(item);
if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".rsp"))
{
using (var workspace = ResponseFileWorkspace.Create())
{
Project project = workspace.OpenCommandLineProject(item, language);
await engine.FormatProjectAsync(project, cancellationToken);
}
}
else if (StringComparer.OrdinalIgnoreCase.Equals(extension, ".sln"))
{
AnalyzerManager manager = new AnalyzerManager(item);
using (var workspace = manager.GetWorkspace())
{
var solution = workspace.CurrentSolution;
await engine.FormatSolutionAsync(solution, cancellationToken);
}
}
else
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(item);
using (var workspace = analyzer.GetWorkspace())
{
var project = workspace.CurrentSolution.Projects.FirstOrDefault();
await engine.FormatProjectAsync(project, cancellationToken);
}
}
}
/*
* To get a Roslyn workspace, we use the Buildalyzer to build the solution in design
* mode. This allows it work out all the depencies that need to be referenced in order
* for the Roslyn compiler to succeed.
*
* The BuildSolution method below uses Buildalyzer to first load a solution, and
* then build each project separately. The build log can be optionally written
* to a file, if the `--buildlog` option was given.
*/
private Solution BuildSolution()
{
var logwriter = _options.BuildLog != null?
File.CreateText(_options.BuildLog) :
TextWriter.Null;
using (logwriter)
{
var amanager = new AnalyzerManager(_options.Solution,
new AnalyzerManagerOptions()
{
LogWriter = logwriter
});
foreach (var proj in amanager.Projects)
{
proj.Value.SetGlobalProperty("OutputPath", Path.GetTempPath());
ConsoleOut("Building project {0}", proj.Key);
proj.Value.Build();
}
if (_options.BuildLog != null)
{
ConsoleOut("Build log written to {0}", _options.BuildLog);
}
return(amanager.GetWorkspace().CurrentSolution);
}
}
static TestProject()
{
var manager = new AnalyzerManager();
manager.GetProject(@"../../../../AOTMapper.TestProject/AOTMapper.TestProject.csproj");
var workspace = manager.GetWorkspace();
Project = workspace.CurrentSolution.Projects.First(o => o.Name == "AOTMapper.TestProject");
}
internal Options(
IEnumerable <Project> projects = null,
IEnumerable <string> projectPaths = null,
IEnumerable <string> sourcePaths = null,
IEnumerable <IEnumerable <string> > symbolConfigurations = null,
IEnumerable <string> alwaysIgnoredSymbols = null,
IEnumerable <string> alwaysDefinedSymbols = null,
IEnumerable <string> alwaysDisabledSymbols = null,
Tristate undefinedSymbolValue = default(Tristate),
IAnalysisLogger logger = null)
{
if (projectPaths != null)
{
List <Project> projectsToAdd = new List <Project>();
projectPaths.ToList().ForEach(filePath =>
{
AnalyzerManager analyzerManager = new AnalyzerManager();
ProjectAnalyzer analyzer = analyzerManager.GetProject(filePath);
projectsToAdd.AddRange(analyzerManager.GetWorkspace().CurrentSolution.Projects);
});
projects = projectsToAdd.AsEnumerable();
}
if (projects != null)
{
Documents = GetSharedDocuments(projects);
}
if (projects == null && sourcePaths != null)
{
var projectId = ProjectId.CreateNewId("AnalysisProject");
var solution = new AdhocWorkspace()
.CurrentSolution
.AddProject(projectId, "AnalysisProject", "AnalysisProject", LanguageNames.CSharp);
foreach (var path in sourcePaths)
{
var documentId = DocumentId.CreateNewId(projectId);
solution = solution.AddDocument(
documentId,
Path.GetFileName(path),
new FileTextLoader(path, defaultEncoding: Encoding.UTF8));
}
Documents = solution.Projects.Single().Documents.ToImmutableArray();
}
_symbolConfigurations = CalculateSymbolConfigurations(
alwaysDisabledSymbols,
alwaysDefinedSymbols,
alwaysIgnoredSymbols,
symbolConfigurations);
_undefinedSymbolValue = undefinedSymbolValue;
Logger = logger ?? new ConsoleAnalysisLogger();
}
/// <inheritdoc />
protected override IEnumerable <Project> GetProjects(IFile file)
{
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(file.Path.Directory.FullPath, log);
foreach (ProjectAnalyzer analyzer in manager.Projects.Values)
{
CompileProjectAndTrace(analyzer, log);
}
Workspace workspace = manager.GetWorkspace();
return(workspace.CurrentSolution.Projects);
}
static async Task <int> Main(string[] args)
{
try
{
var arguments = Args.Parse <Arguments>(args);
var language = arguments.Language.GetValueOrDefault(DetermineLanguageByOutputFileName(arguments.OutputFile));
var logSink = arguments.Verbose ? (ILogSink)ConsoleLogSink.Instance : NullLogSink.Instance;
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(new LogSinkLoggerProvider(logSink));
var options = new AnalyzerManagerOptions
{
LoggerFactory = loggerFactory,
};
var manager = new AnalyzerManager(arguments.SolutionFile, options);
var workspace = manager.GetWorkspace();
var compilationTasks = workspace
.CurrentSolution
.Projects
.Select(project => project.GetCompilationAsync());
var compilations = await Task.WhenAll(compilationTasks);
var syntaxNodes = XmlBasedGenerator.GenerateMocks(
logSink,
language,
compilations.ToImmutableList(),
arguments.ConfigurationFile);
var result = syntaxNodes
.Aggregate(
new StringBuilder(),
(acc, next) => acc.AppendLine(next.ToFullString()).AppendLine(),
acc => acc.ToString());
var log = logSink.ToString();
File.WriteAllText(arguments.OutputFile, result);
return(0);
}
catch (ArgException ex)
{
WriteLine(OutputType.Error, ex.Message);
WriteLine();
WriteLine(ArgUsage.GenerateUsageFromTemplate <Arguments>().ToNormalString());
return(-1);
}
catch (Exception ex)
{
WriteLine(OutputType.Error, "Failed to generate code: {0}", ex);
return(-1);
}
}
public void LoadsSolution()
{
// Given
string solutionPath = GetFullPath(@"projects\TestProjects.sln");
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(solutionPath, new AnalyzerManagerOptions {
LogWriter = log
});
// When
Workspace workspace = manager.GetWorkspace();
// Then
workspace.CurrentSolution.FilePath.ShouldBe(solutionPath);
workspace.CurrentSolution.Projects.ShouldContain(p => p.Name == "LegacyFrameworkProject");
workspace.CurrentSolution.Projects.ShouldContain(p => p.Name == "SdkFrameworkProject");
}
public static async Task <AnalysisEngine> FromFilePaths(
IEnumerable <string> filePaths,
IEnumerable <IEnumerable <string> > symbolConfigurations = null,
IEnumerable <string> alwaysIgnoredSymbols = null,
IEnumerable <string> alwaysDefinedSymbols = null,
IEnumerable <string> alwaysDisabledSymbols = null,
Tristate undefinedSymbolValue = default(Tristate),
CancellationToken cancellationToken = default(CancellationToken))
{
if (filePaths == null || !filePaths.Any())
{
throw new ArgumentException("Must specify at least one file path");
}
IEnumerable <string> sourcePaths = null;
List <Project> projects = new List <Project>();
var firstFileExt = Path.GetExtension(filePaths.First());
if (firstFileExt.EndsWith("proj", StringComparison.OrdinalIgnoreCase))
{
filePaths.ToList().ForEach(filePath =>
{
AnalyzerManager manager = new AnalyzerManager();
ProjectAnalyzer analyzer = manager.GetProject(filePath);
projects.AddRange(manager.GetWorkspace().CurrentSolution.Projects);
});
}
else
{
sourcePaths = filePaths;
}
var options = new Options(
projects: projects,
sourcePaths: sourcePaths,
symbolConfigurations: symbolConfigurations,
alwaysIgnoredSymbols: alwaysIgnoredSymbols,
alwaysDefinedSymbols: alwaysDefinedSymbols,
alwaysDisabledSymbols: alwaysDisabledSymbols,
undefinedSymbolValue: undefinedSymbolValue);
return(new AnalysisEngine(options));
}
static void Main(string[] args)
{
var mgr = new AnalyzerManager(new AnalyzerManagerOptions());
var proj = mgr.GetProject(MVCAPP);
var cop = proj.Compile();
Workspace workspace = mgr.GetWorkspace();
Compilation compilation = workspace.CurrentSolution.Projects.First().GetCompilationAsync().Result;
var controllerSymbols = compilation.GetSymbolsWithName(x => x.EndsWith("Controller"));
foreach (var controller in controllerSymbols)
{
foreach (var controllerTree in controller.DeclaringSyntaxReferences)
{
AnalyseController(controllerTree.SyntaxTree);
}
}
}
/// <inheritdoc />
protected override IEnumerable <Project> GetProjects(IExecutionContext context, IFile file)
{
StringWriter log = new StringWriter();
AnalyzerManager manager = new AnalyzerManager(file.Path.Directory.FullPath, new AnalyzerManagerOptions
{
LogWriter = log
});
foreach (ProjectAnalyzer analyzer in manager.Projects.Values)
{
if (context.Bool(CodeAnalysisKeys.OutputBuildLog))
{
analyzer.WithBinaryLog();
}
CompileProjectAndTrace(analyzer, log);
}
Workspace workspace = manager.GetWorkspace();
return(workspace.CurrentSolution.Projects);
}
/*
* To get a Roslyn workspace, we use the Buildalyzer to build the solution in design
* mode. This allows it work out all the depencies that need to be referenced in order
* for the Roslyn compiler to succeed.
*
* The BuildSolution method below uses Buildalyzer to first load a solution, and
* then build each project separately. The build log can be optionally written
* to a file, if the `--buildlog` option was given.
*/
private Solution BuildSolution()
{
var logwriter = _options.BuildLog != null?
File.CreateText(_options.BuildLog) :
TextWriter.Null;
using (logwriter)
{
var amanager = new AnalyzerManager(Path.GetFullPath(_options.Solution),
new AnalyzerManagerOptions()
{
LogWriter = logwriter
});
ConsoleOut("Building solution...");
var solution = amanager.GetWorkspace().CurrentSolution;
if (_options.BuildLog != null)
{
ConsoleOut("Build log written to {0}", _options.BuildLog);
}
return(solution);
}
}
static void Main()
{
// However you might want to change this filepath for your testing
var solutionFilePath = Directory.GetCurrentDirectory() + @"/Benchmarks/eShopOnWeb/eShopOnWeb.sln";
Console.WriteLine("Parsing solution... " + solutionFilePath);
if (!File.Exists(solutionFilePath))
{
Console.WriteLine("File not found, the folder " + Directory.GetCurrentDirectory()
+ " should be the one containing the Benchmarks folder, so the root directory of the git repo");
return;
}
var manager = new AnalyzerManager(solutionFilePath);
var workspace = manager.GetWorkspace();
var projects = workspace.CurrentSolution.Projects;
Console.WriteLine("Parsing source code for expected issues and traps...");
Helper.AnalyzeWalker(projects, new ExpectedIssueWalker());
IssueReporter.Instance.EndExpectMode();
Console.WriteLine("Analyzing source code...");
var walkersNames = Assembly.GetExecutingAssembly().GetTypes()
.Where(t => String.Equals(t.Namespace, "Compiler.IssueWalkers", StringComparison.Ordinal));
var walkers = walkersNames.Select(x => Activator.CreateInstance(x)).OfType <DefaultWalker>();
Helper.AnalyzeWalkers(projects, walkers);
// And reporting results
var sw = new StreamWriter(Console.OpenStandardOutput());
sw.AutoFlush = true;
Console.SetOut(sw);
IssueReporter.Instance.Report(sw);
}
public static async Task <int> GoAsync(string[] args)
{
//.NET core csprojects are not supported all that well.
// https://github.com/dotnet/roslyn/issues/21660 :sadpanda:
// Use Buildalyzer to get a workspace from the solution.
var options = new AnalyzerManagerOptions()
{
ProjectFilter = p => ProjectsWeWant.Contains(p.ProjectName)
};
var analyzer = new AnalyzerManager(Path.Combine(Program.InputDirPath, "..", "Elasticsearch.sln"), options);
var workspace = analyzer.GetWorkspace();
var seenFailures = false;
workspace.WorkspaceFailed += (s, e) =>
{
Console.Error.WriteLine($"Workplace failure: {e.Diagnostic.Message}");
seenFailures = true;
};
// Buildalyzer, similar to MsBuildWorkspace with the new csproj file format, does
// not pick up source documents in the project directory. Manually add them
// AddDocumentsToWorkspace(workspace);
var projects = workspace.CurrentSolution.Projects
.ToDictionary(p => p.Name, StringComparer.OrdinalIgnoreCase);
if (seenFailures)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine("Documentation failed to generate.");
Console.ResetColor();
return(2);
}
DeleteExistingTmpDocs();
foreach (var file in GetDocumentFiles(projects).SelectMany(s => s))
{
await file.SaveToDocumentationFolderAsync();
}
if (seenFailures)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.Error.WriteLine("Documentation failed to generate.");
Console.ResetColor();
return(2);
}
CopyBreakingChangesDocs();
DeleteExistingDocsAndSwap();
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("Documentation generated.");
Console.ResetColor();
if (Debugger.IsAttached)
{
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
return(0);
}
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 override async Task <IDataToSent> TransformData(IDataToSent receiveData)
{
if (!File.Exists(fileNameSln))
{
throw new FileNotFoundException(fileNameSln);
}
if (receiveData == null)
{
receiveData = new DataToSentTable();
}
var manager = new AnalyzerManager(fileNameSln);
var sol = manager.GetWorkspace().CurrentSolution;
var dtSolution = new DataTable();
dtSolution.TableName = "solutions";
dtSolution.Columns.Add("Name", typeof(string));
dtSolution.Columns.Add("FilePath", typeof(string));
dtSolution.Columns.Add("Type", typeof(string));
dtSolution.Rows.Add(Path.GetFileNameWithoutExtension(fileNameSln), fileNameSln);
var dtProjects = new DataTable();
dtProjects.TableName = "projects";
dtProjects.Columns.Add("Id", typeof(string));
dtProjects.Columns.Add("SolutionFilePath", typeof(string));
dtProjects.Columns.Add("Name", typeof(string));
dtProjects.Columns.Add("FilePath", typeof(string));
dtProjects.Columns.Add("Type", typeof(string));
var dtRelationProject = new DataTable();
dtRelationProject.TableName = "projectReferences";
dtRelationProject.Columns.Add("PrjId", typeof(string));
dtRelationProject.Columns.Add("RefPrjId", typeof(string));
var dtAssemblies = new DataTable();
dtAssemblies.TableName = "assemblies";
dtAssemblies.Columns.Add("Name", typeof(string));
dtAssemblies.Columns.Add("DisplayNameToken", typeof(string));
dtAssemblies.Columns.Add("FullName", typeof(string));
dtAssemblies.Columns.Add("Version", typeof(string));
var dtRelProjectAssemblies = new DataTable();
dtRelProjectAssemblies.TableName = "projectAssemblies";
dtRelProjectAssemblies.Columns.Add("PrjId", typeof(string));
dtRelProjectAssemblies.Columns.Add("FullName", typeof(string));
var existsAssemblies = new List <string>();
foreach (var prj in sol.Projects)
{
var id = prj.Id.Id.ToString("N");
dtProjects.Rows.Add(
id,
fileNameSln,
prj.Name,
prj.FilePath,
prj.GetType().Name
);
foreach (var prjProjectReference in prj.ProjectReferences)
{
dtRelationProject.Rows.Add(id, prjProjectReference.ProjectId.Id.ToString("N"));
}
var c = await prj.GetCompilationAsync();
foreach (var referencedAssemblyName in c.ReferencedAssemblyNames)
{
var fullName = referencedAssemblyName.GetDisplayName(true);
if (!existsAssemblies.Contains(fullName))
{
existsAssemblies.Add(fullName);
dtAssemblies.Rows.Add(referencedAssemblyName.Name,
referencedAssemblyName.GetDisplayName(false),
fullName,
referencedAssemblyName.Version.ToString());
}
dtRelProjectAssemblies.Rows.Add(id, fullName);
}
//TODO: project.MetadataReferences
}
FastAddTables(receiveData, dtSolution, dtProjects, dtRelationProject, dtAssemblies, dtRelProjectAssemblies);
return(receiveData);
}
