public PEAssemblyBuilderBase(
SourceAssemblySymbol sourceAssembly,
EmitOptions emitOptions,
OutputKind outputKind,
Cci.ModulePropertiesForSerialization serializationProperties,
IEnumerable <ResourceDescription> manifestResources,
ImmutableArray <NamedTypeSymbol> additionalTypes
)
: base(
(SourceModuleSymbol)sourceAssembly.Modules[0],
emitOptions,
outputKind,
serializationProperties,
manifestResources
)
{
Debug.Assert(sourceAssembly is object);
_sourceAssembly = sourceAssembly;
_additionalTypes = additionalTypes.NullToEmpty();
_metadataName =
(emitOptions.OutputNameOverride == null)
? sourceAssembly.MetadataName
: FileNameUtilities.ChangeExtension(
emitOptions.OutputNameOverride,
extension: null
);
AssemblyOrModuleSymbolToModuleRefMap.Add(sourceAssembly, this);
}
public string Execute(string path)
{
var folderName = Path.GetFileName(path);
var parentPath = path.Substring(0, path.Length - folderName.Length);
folderName = FileNameUtilities.Sanitize(folderName);
return(Path.Combine(parentPath, folderName));
}
public string Execute(QueuedDownloadToken item)
{
var folderName = item.Token.StudyName;
if (item.Token.Job != null)
{
folderName += " - " + item.Token.Job.JobName;
}
return(FileNameUtilities.Sanitize(folderName));
}
/// <summary>
/// Determines whether an assembly reference is considered an assembly file path or an assembly name.
/// used, for example, on values of /r and #r.
/// </summary>
public static bool IsFilePath(string assemblyDisplayNameOrPath)
{
Debug.Assert(assemblyDisplayNameOrPath != null);
string extension = FileNameUtilities.GetExtension(assemblyDisplayNameOrPath);
return(string.Equals(extension, ".dll", StringComparison.OrdinalIgnoreCase) ||
string.Equals(extension, ".exe", StringComparison.OrdinalIgnoreCase) ||
assemblyDisplayNameOrPath.IndexOf(DirectorySeparatorChar) != -1 ||
assemblyDisplayNameOrPath.IndexOf(AltDirectorySeparatorChar) != -1);
}
public DocumentId AddTextContainer(SourceTextContainer textContainer, string fullPath, SourceCodeKind sourceCodeKind, ImmutableArray <string> folders)
{
if (textContainer == null)
{
throw new ArgumentNullException(nameof(textContainer));
}
var documentId = DocumentId.CreateNewId(_project.Id, fullPath);
var textLoader = new SourceTextLoader(textContainer, fullPath);
var documentInfo = DocumentInfo.Create(
documentId,
FileNameUtilities.GetFileName(fullPath),
folders: folders.IsDefault ? null : (IEnumerable <string>)folders,
sourceCodeKind: sourceCodeKind,
loader: textLoader,
filePath: fullPath);
lock (_project._gate)
{
if (_sourceTextContainersToDocumentIds.ContainsKey(textContainer))
{
throw new ArgumentException($"{nameof(textContainer)} is already added to this project.", nameof(textContainer));
}
if (fullPath != null)
{
if (_documentPathsToDocumentIds.ContainsKey(fullPath))
{
throw new ArgumentException($"'{fullPath}' has already been added to this project.");
}
_documentPathsToDocumentIds.Add(fullPath, documentId);
}
_sourceTextContainersToDocumentIds = _sourceTextContainersToDocumentIds.Add(textContainer, documentInfo.Id);
if (_project._activeBatchScopes > 0)
{
_documentsAddedInBatch.Add(documentInfo);
}
else
{
_project._workspace.ApplyChangeToWorkspace(w =>
{
_project._workspace.AddDocumentToDocumentsNotFromFiles(documentInfo.Id);
_documentAddAction(w, documentInfo);
w.OnDocumentOpened(documentInfo.Id, textContainer);
});
}
}
return(documentId);
}
public void ExportPngAndCompareWithBaseline()
{
const string DestinationDirectory = "ExampleLibrary.Actual";
const string BaselineDirectory = "ExampleLibrary.Baseline";
const string DiffDirectory = "ExampleLibrary.Diff";
if (!Directory.Exists(BaselineDirectory))
{
Directory.CreateDirectory(BaselineDirectory);
}
if (!Directory.Exists(DestinationDirectory))
{
Directory.CreateDirectory(DestinationDirectory);
}
if (!Directory.Exists(DiffDirectory))
{
Directory.CreateDirectory(DiffDirectory);
}
foreach (var example in ExampleLibrary.Examples.GetList())
{
if (example.PlotModel == null)
{
continue;
}
var filename = FileNameUtilities.CreateValidFileName(example.Category + " - " + example.Title, ".png");
var baselinePath = Path.Combine(BaselineDirectory, filename);
var path = Path.Combine(DestinationDirectory, filename);
var diffpath = Path.Combine(DiffDirectory, filename);
PngExporter.Export(example.PlotModel, path, 800, 500, OxyColors.White);
if (File.Exists(baselinePath))
{
PngAssert.AreEqual(baselinePath, path, example.Title, diffpath);
}
else
{
File.Copy(path, baselinePath);
}
}
}
internal override bool GenerateResourcesAndDocumentationComments(CommonPEModuleBuilder moduleBuilder, Stream xmlDocStream, Stream win32Resources, string outputNameOverride, DiagnosticBag diagnostics, CancellationToken cancellationToken)
{
// Use a temporary bag so we don't have to refilter pre-existing diagnostics.
DiagnosticBag methodBodyDiagnosticBag = DiagnosticBag.GetInstance();
var moduleBeingBuilt = (PEModuleBuilder)moduleBuilder;
try
{
SetupWin32Resources(moduleBeingBuilt, win32Resources, methodBodyDiagnosticBag);
ReportManifestResourceDuplicates(
moduleBeingBuilt.ManifestResources,
SourceAssembly.Modules.Skip(1).Select((m) => m.Name), //all modules except the first one
AddedModulesResourceNames(methodBodyDiagnosticBag),
methodBodyDiagnosticBag);
if (!FilterAndAppendAndFreeDiagnostics(diagnostics, ref methodBodyDiagnosticBag))
{
return(false);
}
}
catch (Exception ex)
{
this.TrackException(ex);
throw;
}
cancellationToken.ThrowIfCancellationRequested();
// Use a temporary bag so we don't have to refilter pre-existing diagnostics.
DiagnosticBag xmlDiagnostics = DiagnosticBag.GetInstance();
string assemblyName = FileNameUtilities.ChangeExtension(moduleBeingBuilt.EmitOptions.OutputNameOverride, extension: null);
DocumentationCommentCompiler.WriteDocumentationCommentXml(this, assemblyName, xmlDocStream, xmlDiagnostics, cancellationToken);
if (!FilterAndAppendAndFreeDiagnostics(diagnostics, ref xmlDiagnostics))
{
return(false);
}
return(true);
}
private void InitializeDisplayAndId()
{
try
{
// AssemblyName.GetAssemblyName(path) is not available on CoreCLR.
// Use our metadata reader to do the equivalent thing.
using var reader = new PEReader(FileUtilities.OpenRead(FullPath));
var metadataReader = reader.GetMetadataReader();
var assemblyIdentity = metadataReader.ReadAssemblyIdentityOrThrow();
_lazyDisplay = assemblyIdentity.Name;
_lazyIdentity = assemblyIdentity;
}
catch
{
_lazyDisplay = FileNameUtilities.GetFileName(FullPath, includeExtension: false);
_lazyIdentity = _lazyDisplay;
}
}
public DocumentId AddFile(string fullPath, SourceCodeKind sourceCodeKind, ImmutableArray <string> folders)
{
if (string.IsNullOrEmpty(fullPath))
{
throw new ArgumentException($"{nameof(fullPath)} isn't a valid path.", nameof(fullPath));
}
var documentId = DocumentId.CreateNewId(_project.Id, fullPath);
var textLoader = new FileTextLoader(fullPath, defaultEncoding: null);
var documentInfo = DocumentInfo.Create(
documentId,
FileNameUtilities.GetFileName(fullPath),
folders: folders.IsDefault ? null : (IEnumerable <string>)folders,
sourceCodeKind: sourceCodeKind,
loader: textLoader,
filePath: fullPath);
lock (_project._gate)
{
if (_documentPathsToDocumentIds.ContainsKey(fullPath))
{
throw new ArgumentException($"'{fullPath}' has already been added to this project.", nameof(fullPath));
}
_documentPathsToDocumentIds.Add(fullPath, documentId);
_project._fileWatchingTokens.Add(documentId, _project._documentFileChangeContext.EnqueueWatchingFile(fullPath));
if (_project._activeBatchScopes > 0)
{
_documentsAddedInBatch.Add(documentInfo);
}
else
{
_project._workspace.ApplyChangeToWorkspace(w => _documentAddAction(w, documentInfo));
_project._workspace.CheckForOpenDocuments(ImmutableArray.Create(fullPath));
}
}
return(documentId);
}
public static string GetExtension(string path)
{
return(FileNameUtilities.GetExtension(path));
}
private void ProgressUpdated(string filePathOpt)
{
var current = DateTimeOffset.UtcNow;
if (current - _lastTimeReported < s_minimumInterval)
{
// make sure we are not flooding UI.
// this is just presentation, fine to not updating UI especially since
// at the end, this notification will go away automatically
return;
}
_lastTimeReported = current;
ChangeProgress(_taskHandler, filePathOpt != null ? string.Format(ServicesVSResources.Analyzing_0, FileNameUtilities.GetFileName(filePathOpt)) : null);
}
public static string GetFileName(string path, bool includeExtension = true)
{
return(FileNameUtilities.GetFileName(path, includeExtension));
}
public static string RemoveExtension(string path)
{
return(FileNameUtilities.ChangeExtension(path, extension: null));
}
internal override bool CompileImpl(CommonPEModuleBuilder moduleBuilder, Stream win32Resources, Stream xmlDocStream, bool emittingPdb, DiagnosticBag diagnostics, Predicate <ISymbol> filterOpt, CancellationToken cancellationToken)
{
// The diagnostics should include syntax and declaration errors. We insert these before calling Emitter.Emit, so that the emitter
// does not attempt to emit if there are declaration errors (but we do insert all errors from method body binding...)
bool hasDeclarationErrors = false; // !FilterAndAppendDiagnostics(diagnostics, GetDiagnostics(CompilationStage.Declare, true, cancellationToken));
var moduleBeingBuilt = (PEModuleBuilder)moduleBuilder;
if (moduleBeingBuilt.EmitOptions.EmitMetadataOnly)
{
throw new NotImplementedException();
}
// Perform initial bind of method bodies in spite of earlier errors. This is the same
// behavior as when calling GetDiagnostics()
// Use a temporary bag so we don't have to refilter pre-existing diagnostics.
DiagnosticBag methodBodyDiagnosticBag = DiagnosticBag.GetInstance();
SourceCompiler.CompileSources(
this,
moduleBeingBuilt,
emittingPdb,
hasDeclarationErrors,
methodBodyDiagnosticBag,
cancellationToken);
SetupWin32Resources(moduleBeingBuilt, win32Resources, methodBodyDiagnosticBag);
ReportManifestResourceDuplicates(
moduleBeingBuilt.ManifestResources,
SourceAssembly.Modules.Skip(1).Select((m) => m.Name), //all modules except the first one
AddedModulesResourceNames(methodBodyDiagnosticBag),
methodBodyDiagnosticBag);
bool hasMethodBodyErrorOrWarningAsError = !FilterAndAppendAndFreeDiagnostics(diagnostics, ref methodBodyDiagnosticBag);
if (hasDeclarationErrors || hasMethodBodyErrorOrWarningAsError)
{
return(false);
}
cancellationToken.ThrowIfCancellationRequested();
// Use a temporary bag so we don't have to refilter pre-existing diagnostics.
DiagnosticBag xmlDiagnostics = DiagnosticBag.GetInstance();
string assemblyName = FileNameUtilities.ChangeExtension(moduleBeingBuilt.EmitOptions.OutputNameOverride, extension: null);
DocumentationCommentCompiler.WriteDocumentationCommentXml(this, assemblyName, xmlDocStream, xmlDiagnostics, cancellationToken);
if (!FilterAndAppendAndFreeDiagnostics(diagnostics, ref xmlDiagnostics))
{
return(false);
}
//// Use a temporary bag so we don't have to refilter pre-existing diagnostics.
//DiagnosticBag importDiagnostics = DiagnosticBag.GetInstance();
//this.ReportUnusedImports(importDiagnostics, cancellationToken);
//if (!FilterAndAppendAndFreeDiagnostics(diagnostics, ref importDiagnostics))
//{
// Debug.Assert(false, "Should never produce an error");
// return false;
//}
return(true);
}
/// <summary>
/// Checks that the specified name is a valid metadata String and a file name.
/// The specification isn't entirely consistent and complete but it mentiones:
///
/// 22.19.2: "Name shall index a non-empty string in the String heap. It shall be in the format {filename}.{extension} (e.g., 'foo.dll', but not 'c:\utils\foo.dll')."
/// 22.30.2: "The format of Name is {file name}.{file extension} with no path or drive letter; on POSIX-compliant systems Name contains no colon, no forward-slash, no backslash."
/// As Microsoft specific constraint.
///
/// A reasonable restriction seems to be a valid UTF8 non-empty string that doesn't contain '\0', '\', '/', ':' characters.
/// </summary>
internal static bool IsValidMetadataFileName(string name)
{
return(FileNameUtilities.IsFileName(name) && IsValidMetadataIdentifier(name));
}
public PEAssemblyBuilder(
SourceAssemblySymbol sourceAssembly,
Cci.ModulePropertiesForSerialization serializationProperties,
IEnumerable <ResourceDescription> manifestResources,
OutputKind outputKind,
EmitOptions emitOptions)
: base(sourceAssembly.DeclaringCompilation, (SourceModuleSymbol)sourceAssembly.Modules[0], serializationProperties, manifestResources, outputKind, emitOptions)
{
_sourceAssembly = sourceAssembly;
_metadataName = (emitOptions.OutputNameOverride == null) ? sourceAssembly.MetadataName : FileNameUtilities.ChangeExtension(emitOptions.OutputNameOverride, extension: null);
AssemblyOrModuleSymbolToModuleRefMap.Add(sourceAssembly, this);
}
public PEAssemblyBuilderBase(
SourceAssemblySymbol sourceAssembly,
string outputName,
OutputKind outputKind,
ModulePropertiesForSerialization serializationProperties,
IEnumerable <ResourceDescription> manifestResources,
Func <AssemblySymbol, AssemblyIdentity> assemblySymbolMapper,
ImmutableArray <NamedTypeSymbol> additionalTypes,
bool metadataOnly)
: base((SourceModuleSymbol)sourceAssembly.Modules[0], outputName, outputKind, serializationProperties, manifestResources, assemblySymbolMapper, metadataOnly)
{
Debug.Assert((object)sourceAssembly != null);
this.sourceAssembly = sourceAssembly;
this.additionalTypes = additionalTypes.NullToEmpty();
this.metadataName = outputName == null ? sourceAssembly.MetadataName : FileNameUtilities.ChangeExtension(outputName, extension: null);
AssemblyOrModuleSymbolToModuleRefMap.Add(sourceAssembly, this);
}
public async Task ExecuteAsync(
GetConfigsCommand.Parameters parameters)
{
var configType = parameters.ConfigType;
var username = parameters.Username;
var userId = parameters.UserId;
var outputFolder = parameters.OutputFolder;
var format = parameters.Format;
var unwrap = parameters.Unwrap;
var simVersion = await this.simVersionCache.GetOrSet(parameters.SimVersion);
var authenticatedUser = await this.ensureAuthenticated.ExecuteAsync();
if (!string.IsNullOrWhiteSpace(username))
{
userId = await getUserIdFromUsername.ExecuteAsync(authenticatedUser.TenantId, username);
}
var filter = new JObject(
new JProperty("continuationToken", null));
if (!string.IsNullOrWhiteSpace(userId))
{
filter.Add(
new JProperty("filterUserId", userId));
}
this.logger.LogInformation("Requesting configs...");
GetConfigsQueryResult?result = null;
do
{
if (result != null)
{
filter["continuationToken"] = result.QueryResults.ContinuationToken;
}
result = await this.configClient.GetConfigsAsync(
authenticatedUser.TenantId,
configType,
filter.ToString(Formatting.None),
null,
null);
if (outputFolder != null)
{
var outputFolderPath = this.getCreatedOutputFolder.Execute(outputFolder);
var sizes = new List <int>();
foreach (var configMetadata in result.QueryResults.Documents)
{
this.logger.LogInformation($"Downloading {configMetadata.Name}...");
var config = await this.configClient.GetConfigAsync(
configMetadata.TenantId,
configMetadata.DocumentId,
null,
simVersion,
null);
var content = JObject.FromObject(config.Config.Data);
if (!unwrap)
{
content = new JObject(
new JProperty("simVersion", config.ConvertedSimVersion),
new JProperty("config", content));
}
var formatting = format ? Formatting.Indented : Formatting.None;
var contentString = content.ToString(formatting);
await this.writeFile.ExecuteAsync(
Path.Combine(outputFolderPath, FileNameUtilities.Sanitize(config.Config.Name) + ".json"),
contentString);
sizes.Add(contentString.Length);
}
Utilities.WriteTable(
new[] { "Name", "Id", "UserId", "Size" },
result.QueryResults.Documents
.Zip(sizes, (d, s) => new { d, s }).Select(v => new string[] { v.d.Name, v.d.DocumentId, v.d.UserId, v.s.ToString() }));
}
else
{
Utilities.WriteTable(
new[] { "Name", "Id", "UserId" },
result.QueryResults.Documents.Select(v => new string[] { v.Name, v.DocumentId, v.UserId }));
}
}while (result.QueryResults.HasMoreResults == true);
}
public static string ChangeExtension(string path, string extension)
{
return(FileNameUtilities.ChangeExtension(path, extension));
}
internal static EmitDifferenceResult EmitDifference(
CSharpCompilation compilation,
EmitBaseline baseline,
IEnumerable <SemanticEdit> edits,
Stream metadataStream,
Stream ilStream,
Stream pdbStream,
ICollection <uint> updatedMethodTokens,
CompilationTestData testData,
CancellationToken cancellationToken)
{
Guid moduleVersionId;
try
{
moduleVersionId = baseline.OriginalMetadata.GetModuleVersionId();
}
catch (BadImageFormatException)
{
// return MakeEmitResult(success: false, diagnostics: ..., baseline: null);
throw;
}
var pdbName = FileNameUtilities.ChangeExtension(compilation.SourceModule.Name, "pdb");
var diagnostics = DiagnosticBag.GetInstance();
string runtimeMDVersion = compilation.GetRuntimeMetadataVersion(diagnostics);
var serializationProperties = compilation.ConstructModuleSerializationProperties(runtimeMDVersion, moduleVersionId);
var manifestResources = SpecializedCollections.EmptyEnumerable <ResourceDescription>();
var moduleBeingBuilt = new PEDeltaAssemblyBuilder(
compilation.SourceAssembly,
outputName: null,
outputKind: compilation.Options.OutputKind,
serializationProperties: serializationProperties,
manifestResources: manifestResources,
assemblySymbolMapper: null,
previousGeneration: baseline,
edits: edits);
if (testData != null)
{
moduleBeingBuilt.SetMethodTestData(testData.Methods);
testData.Module = moduleBeingBuilt;
}
baseline = moduleBeingBuilt.PreviousGeneration;
var definitionMap = moduleBeingBuilt.PreviousDefinitions;
var changes = moduleBeingBuilt.Changes;
if (compilation.Compile(
moduleBeingBuilt,
outputName: null,
win32Resources: null,
xmlDocStream: null,
cancellationToken: cancellationToken,
generateDebugInfo: true,
diagnostics: diagnostics,
filterOpt: changes.RequiresCompilation))
{
// Map the definitions from the previous compilation to the current compilation.
// This must be done after compiling above since synthesized definitions
// (generated when compiling method bodies) may be required.
baseline = MapToCompilation(compilation, moduleBeingBuilt);
using (var pdbWriter = new Cci.PdbWriter(pdbName, pdbStream, (testData != null) ? testData.SymWriterFactory : null))
{
var context = new EmitContext(moduleBeingBuilt, null, diagnostics);
var encId = Guid.NewGuid();
try
{
var writer = new DeltaPeWriter(
context,
compilation.MessageProvider,
pdbWriter,
baseline,
encId,
definitionMap,
changes,
cancellationToken);
Cci.MetadataSizes metadataSizes;
writer.WriteMetadataAndIL(metadataStream, ilStream, out metadataSizes);
writer.GetMethodTokens(updatedMethodTokens);
return(new EmitDifferenceResult(
success: true,
diagnostics: diagnostics.ToReadOnlyAndFree(),
baseline: writer.GetDelta(baseline, compilation, encId, metadataSizes)));
}
catch (Cci.PdbWritingException e)
{
diagnostics.Add(ErrorCode.FTL_DebugEmitFailure, Location.None, e.Message);
}
catch (PermissionSetFileReadException e)
{
diagnostics.Add(ErrorCode.ERR_PermissionSetAttributeFileReadError, Location.None, e.FileName, e.PropertyName, e.Message);
}
}
}
return(new EmitDifferenceResult(success: false, diagnostics: diagnostics.ToReadOnlyAndFree(), baseline: null));
}
public override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
#if XSHARP
var parseOptions = Arguments.ParseOptions.WithOutput(consoleOutput);
#else
var parseOptions = Arguments.ParseOptions;
#endif
// We compute script parse options once so we don't have to do it repeatedly in
// case there are many script files.
var scriptParseOptions = parseOptions.WithKind(SourceCodeKind.Script);
bool hadErrors = false;
var sourceFiles = Arguments.SourceFiles;
var trees = new SyntaxTree[sourceFiles.Length];
var normalizedFilePaths = new string[sourceFiles.Length];
var diagnosticBag = DiagnosticBag.GetInstance();
if (Arguments.CompilationOptions.ConcurrentBuild)
{
Parallel.For(0, sourceFiles.Length, UICultureUtilities.WithCurrentUICulture <int>(i =>
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], diagnosticBag, out normalizedFilePaths[i]);
}));
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], diagnosticBag, out normalizedFilePaths[i]);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
Debug.Assert(diagnosticBag.HasAnyErrors());
ReportErrors(diagnosticBag.ToReadOnlyAndFree(), consoleOutput, errorLogger);
return(null);
}
else
{
Debug.Assert(diagnosticBag.IsEmptyWithoutResolution);
diagnosticBag.Free();
}
#if XSHARP
var newtree = InternalSyntax.XSharpLanguageParser.ProcessTrees(trees, parseOptions);
if (newtree != null)
{
var newtrees = new SyntaxTree[trees.Length + 1];
Array.Copy(trees, newtrees, trees.Length);
newtrees[trees.Length] = newtree;
trees = newtrees;
}
#endif
var diagnostics = new List <DiagnosticInfo>();
var uniqueFilePaths = new HashSet <string>(StringComparer.OrdinalIgnoreCase);
for (int i = 0; i < sourceFiles.Length; i++)
{
var normalizedFilePath = normalizedFilePaths[i];
Debug.Assert(normalizedFilePath != null);
Debug.Assert(PathUtilities.IsAbsolute(normalizedFilePath));
if (!uniqueFilePaths.Add(normalizedFilePath))
{
// warning CS2002: Source file '{0}' specified multiple times
diagnostics.Add(new DiagnosticInfo(MessageProvider, (int)ErrorCode.WRN_FileAlreadyIncluded,
Arguments.PrintFullPaths ? normalizedFilePath : _diagnosticFormatter.RelativizeNormalizedPath(normalizedFilePath)));
trees[i] = null;
}
#if XSHARP
else if (parseOptions.PreprocessorOutput && Arguments.TouchedFilesPath != null)
{
touchedFilesLogger.AddWritten(FileNameUtilities.ChangeExtension(normalizedFilePath, ".ppo"));
}
#endif
}
#if XSHARP
// Add the names of the header files that we have processed
foreach (var tree in trees)
{
if (tree != null)
{
if (tree.HasCompilationUnitRoot)
{
var root = tree.GetCompilationUnitRoot();
foreach (var file in root.IncludedFiles)
{
uniqueFilePaths.Add(file.Key);
}
}
}
}
#endif
if (Arguments.TouchedFilesPath != null)
{
foreach (var path in uniqueFilePaths)
{
touchedFilesLogger.AddRead(path);
}
}
var assemblyIdentityComparer = DesktopAssemblyIdentityComparer.Default;
var appConfigPath = this.Arguments.AppConfigPath;
if (appConfigPath != null)
{
try
{
using (var appConfigStream = new FileStream(appConfigPath, FileMode.Open, FileAccess.Read))
{
assemblyIdentityComparer = DesktopAssemblyIdentityComparer.LoadFromXml(appConfigStream);
}
if (touchedFilesLogger != null)
{
touchedFilesLogger.AddRead(appConfigPath);
}
}
catch (Exception ex)
{
diagnostics.Add(new DiagnosticInfo(MessageProvider, (int)ErrorCode.ERR_CantReadConfigFile, appConfigPath, ex.Message));
}
}
var xmlFileResolver = new LoggingXmlFileResolver(Arguments.BaseDirectory, touchedFilesLogger);
var sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray <string> .Empty, Arguments.BaseDirectory, Arguments.PathMap, touchedFilesLogger);
MetadataReferenceResolver referenceDirectiveResolver;
var resolvedReferences = ResolveMetadataReferences(diagnostics, touchedFilesLogger, out referenceDirectiveResolver);
if (ReportErrors(diagnostics, consoleOutput, errorLogger))
{
return(null);
}
var loggingFileSystem = new LoggingStrongNameFileSystem(touchedFilesLogger);
return(CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceDirectiveResolver).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithXmlReferenceResolver(xmlFileResolver).
WithStrongNameProvider(Arguments.GetStrongNameProvider(loggingFileSystem, _tempDirectory)).
WithSourceReferenceResolver(sourceFileResolver)));
}