public void AddDependencyLocationThrowsOnNull()
{
var loader = new DefaultAnalyzerAssemblyLoader();
Assert.Throws <ArgumentNullException>("fullPath", () => loader.AddDependencyLocation(null));
Assert.Throws <ArgumentException>("fullPath", () => loader.AddDependencyLocation("a"));
}
public void ThrowsForMissingFile()
{
var path = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName() + ".dll");
var loader = new DefaultAnalyzerAssemblyLoader();
Assert.ThrowsAny <Exception>(() => loader.LoadFromPath(path));
}
public void BasicLoad()
{
var directory = Temp.CreateDirectory();
var alphaDll = directory.CreateFile("Alpha.dll").WriteAllBytes(TestResources.AssemblyLoadTests.Alpha);
var loader = new DefaultAnalyzerAssemblyLoader();
Assembly alpha = loader.LoadFromPath(alphaDll.Path);
Assert.NotNull(alpha);
}
public void AssemblyLoading()
{
StringBuilder sb = new StringBuilder();
var directory = Temp.CreateDirectory();
var alphaDll = Temp.CreateDirectory()
.CreateFile("Alpha.dll")
.WriteAllBytes(TestResources.AssemblyLoadTests.Alpha);
var betaDll = Temp.CreateDirectory()
.CreateFile("Beta.dll")
.WriteAllBytes(TestResources.AssemblyLoadTests.Beta);
var gammaDll = Temp.CreateDirectory()
.CreateFile("Gamma.dll")
.WriteAllBytes(TestResources.AssemblyLoadTests.Gamma);
var deltaDll = Temp.CreateDirectory()
.CreateFile("Delta.dll")
.WriteAllBytes(TestResources.AssemblyLoadTests.Delta);
var loader = new DefaultAnalyzerAssemblyLoader();
loader.AddDependencyLocation(alphaDll.Path);
loader.AddDependencyLocation(betaDll.Path);
loader.AddDependencyLocation(gammaDll.Path);
loader.AddDependencyLocation(deltaDll.Path);
Assembly alpha = loader.LoadFromPath(alphaDll.Path);
var a = alpha.CreateInstance("Alpha.A");
a.GetType().GetMethod("Write").Invoke(a, new object[] { sb, "Test A" });
Assembly beta = loader.LoadFromPath(betaDll.Path);
var b = beta.CreateInstance("Beta.B");
b.GetType().GetMethod("Write").Invoke(b, new object[] { sb, "Test B" });
var expected =
@"Delta: Gamma: Alpha: Test A
Delta: Gamma: Beta: Test B
";
var actual = sb.ToString();
Assert.Equal(expected, actual);
}
public static IServiceProvider Create(
ITestOutputHelper testOutput,
IOmniSharpEnvironment environment,
IConfiguration configurationData = null,
DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current,
IEventEmitter eventEmitter = null)
{
var loggerFactory = new LoggerFactory()
.AddXunit(testOutput);
eventEmitter = eventEmitter ?? NullEventEmitter.Instance;
var assemblyLoader = CreateAssemblyLoader(loggerFactory);
var dotNetCliService = CreateDotNetCliService(dotNetCliVersion, loggerFactory, environment, eventEmitter);
var configuration = CreateConfiguration(configurationData);
var msbuildLocator = CreateMSBuildLocator(loggerFactory, assemblyLoader);
var sharedTextWriter = CreateSharedTextWriter(testOutput);
var analyzerAssemblyLoader = new DefaultAnalyzerAssemblyLoader();
return(new TestServiceProvider(
environment, loggerFactory, assemblyLoader, analyzerAssemblyLoader, sharedTextWriter,
msbuildLocator, eventEmitter, dotNetCliService, configuration));
}
public static async Task <CompilerInvocation> CreateFromJsonAsync(string jsonContents)
{
var invocationInfo = JsonConvert.DeserializeObject <CompilerInvocationInfo>(jsonContents);
// We will use a Workspace to simplify the creation of the compilation, but will be careful not to return the Workspace instance from this class.
// We will still provide the language services which are used by the generator itself, but we don't tie it to a Workspace object so we can
// run this as an in-proc source generator if one day desired.
var workspace = new AdhocWorkspace();
var languageName = GetLanguageName(invocationInfo);
var languageServices = workspace.Services.GetLanguageServices(languageName);
var mapPath = GetPathMapper(invocationInfo);
var splitCommandLine = CommandLineParser.SplitCommandLineIntoArguments(invocationInfo.Arguments, removeHashComments: false).ToList();
// Unfortunately for us there are a few paths that get directly read by the command line parse which we need to remap,
// such as /ruleset files. So let's go through and process them now.
for (var i = 0; i < splitCommandLine.Count; i++)
{
const string RuleSetSwitch = "/ruleset:";
if (splitCommandLine[i].StartsWith(RuleSetSwitch, StringComparison.Ordinal))
{
var rulesetPath = splitCommandLine[i].Substring(RuleSetSwitch.Length);
var quoted = rulesetPath.Length > 2 &&
rulesetPath.StartsWith("\"", StringComparison.Ordinal) &&
rulesetPath.EndsWith("\"", StringComparison.Ordinal);
if (quoted)
{
rulesetPath = rulesetPath.Substring(1, rulesetPath.Length - 2);
}
rulesetPath = mapPath(rulesetPath);
if (quoted)
{
rulesetPath = "\"" + rulesetPath + "\"";
}
splitCommandLine[i] = RuleSetSwitch + rulesetPath;
}
}
var commandLineParserService = languageServices.GetRequiredService <ICommandLineParserService>();
var parsedCommandLine = commandLineParserService.Parse(splitCommandLine, Path.GetDirectoryName(invocationInfo.ProjectFilePath), isInteractive: false, sdkDirectory: null);
var analyzerLoader = new DefaultAnalyzerAssemblyLoader();
var projectId = ProjectId.CreateNewId(invocationInfo.ProjectFilePath);
var projectInfo = ProjectInfo.Create(
projectId,
VersionStamp.Default,
name: Path.GetFileNameWithoutExtension(invocationInfo.ProjectFilePath),
assemblyName: parsedCommandLine.CompilationName !,
language: languageName,
filePath: invocationInfo.ProjectFilePath,
outputFilePath: parsedCommandLine.OutputFileName,
parsedCommandLine.CompilationOptions,
parsedCommandLine.ParseOptions,
parsedCommandLine.SourceFiles.Select(s => CreateDocumentInfo(unmappedPath: s.Path)),
metadataReferences: parsedCommandLine.MetadataReferences.Select(r => MetadataReference.CreateFromFile(mapPath(r.Reference), r.Properties)),
additionalDocuments: parsedCommandLine.AdditionalFiles.Select(f => CreateDocumentInfo(unmappedPath: f.Path)),
analyzerReferences: parsedCommandLine.AnalyzerReferences.Select(r => new AnalyzerFileReference(r.FilePath, analyzerLoader)))
.WithAnalyzerConfigDocuments(parsedCommandLine.AnalyzerConfigPaths.Select(CreateDocumentInfo));
workspace.AddProject(projectInfo);
var compilation = await workspace.CurrentSolution.GetProject(projectId) !.GetRequiredCompilationAsync(CancellationToken.None);
return(new CompilerInvocation(compilation, languageServices, invocationInfo.ProjectFilePath, workspace.CurrentSolution.Options));
// Local methods:
DocumentInfo CreateDocumentInfo(string unmappedPath)
{
var mappedPath = mapPath(unmappedPath);
return(DocumentInfo.Create(
DocumentId.CreateNewId(projectId, mappedPath),
name: mappedPath,
filePath: mappedPath,
loader: new FileTextLoader(mappedPath, parsedCommandLine.Encoding)));
}
}
