public override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
var parseOptions = Arguments.ParseOptions;
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];
if (Arguments.CompilationOptions.ConcurrentBuild)
{
Parallel.For(0, sourceFiles.Length, UICultureUtilities.WithCurrentUICulture <int>(i =>
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger, out normalizedFilePaths[i]);
}));
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger, out normalizedFilePaths[i]);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return(null);
}
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 (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 metadataProvider = GetMetadataProvider();
var xmlFileResolver = new LoggingXmlFileResolver(Arguments.BaseDirectory, touchedFilesLogger);
var sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray <string> .Empty, Arguments.BaseDirectory, touchedFilesLogger);
var externalReferenceResolver = GetExternalMetadataResolver(touchedFilesLogger);
MetadataFileReferenceResolver referenceDirectiveResolver;
var resolvedReferences = ResolveMetadataReferences(externalReferenceResolver, metadataProvider, diagnostics, assemblyIdentityComparer, touchedFilesLogger, out referenceDirectiveResolver);
if (ReportErrors(diagnostics, consoleOutput, errorLogger))
{
return(null);
}
var strongNameProvider = new LoggingStrongNameProvider(Arguments.KeyFileSearchPaths, touchedFilesLogger);
var compilation = CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(new AssemblyReferenceResolver(referenceDirectiveResolver, metadataProvider)).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver));
return(compilation);
}
public override Compilation?CreateCompilation(
TextWriter consoleOutput,
TouchedFileLogger touchedFilesLogger,
ErrorLogger errorLogger,
ImmutableArray <AnalyzerConfigOptionsResult> analyzerConfigOptions,
AnalyzerConfigOptionsResult globalConfigOptions)
{
var parseOptions = Arguments.ParseOptions;
// 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 =>
{
try
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(
parseOptions,
scriptParseOptions,
ref hadErrors,
sourceFiles[i],
diagnosticBag,
out normalizedFilePaths[i]);
}
catch (Exception e) when(FatalError.Report(e))
{
throw ExceptionUtilities.Unreachable;
}
}));
}
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 (ReportDiagnostics(diagnosticBag.ToReadOnlyAndFree(), consoleOutput, errorLogger))
{
Debug.Assert(hadErrors);
return(null);
}
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(sourceFiles[i].IsInputRedirected || 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 (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 (ReportDiagnostics(diagnostics, consoleOutput, errorLogger))
{
return(null);
}
var loggingFileSystem = new LoggingStrongNameFileSystem(touchedFilesLogger, _tempDirectory);
var optionsProvider = new CompilerSyntaxTreeOptionsProvider(trees, analyzerConfigOptions, globalConfigOptions);
return(CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions
.WithMetadataReferenceResolver(referenceDirectiveResolver)
.WithAssemblyIdentityComparer(assemblyIdentityComparer)
.WithXmlReferenceResolver(xmlFileResolver)
.WithStrongNameProvider(Arguments.GetStrongNameProvider(loggingFileSystem))
.WithSourceReferenceResolver(sourceFileResolver)
.WithSyntaxTreeOptionsProvider(optionsProvider)));
}
public override Compilation CreateCompilation(TextWriter output, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
using (Operation op = L.Begin("Creating PHP compilation"))
{
if (!Engine.ParseFiles())
{
return(null);
}
DesktopAssemblyIdentityComparer assemblyIdentityComparer = DesktopAssemblyIdentityComparer.Default;
LoggingXmlFileResolver xmlFileResolver = new LoggingXmlFileResolver(Engine.BaseDirectory, touchedFilesLogger);
LoggingSourceFileResolver sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray <string> .Empty, Engine.CompilerArguments.BaseDirectory,
Engine.CompilerArguments.PathMap, touchedFilesLogger);
MetadataReferenceResolver referenceDirectiveResolver;
List <DiagnosticInfo> resolvedReferencesDiagnostics = new List <DiagnosticInfo>();
List <MetadataReference> resolvedReferences = ResolveMetadataReferences(resolvedReferencesDiagnostics, touchedFilesLogger, out referenceDirectiveResolver);
if (ReportErrors(resolvedReferencesDiagnostics, output, errorLogger))
{
L.Error("Error(s) reported resolving references: {0}", resolvedReferencesDiagnostics);
return(null);
}
MetadataReferenceResolver referenceResolver = GetCommandLineMetadataReferenceResolver(touchedFilesLogger);
LoggingStrongNameProvider strongNameProvider = new LoggingStrongNameProvider(Engine.CompilerArguments.KeyFileSearchPaths, touchedFilesLogger);
try
{
PhpCompilation = PhpCompilation.Create(
Engine.CompilerArguments.CompilationName,
Engine.SyntaxTrees,
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceResolver).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver)
);
}
catch (Exception e)
{
L.Error(e, "An exception was thrown during parsing.");
}
finally
{
/*
* ErrorStream.Flush();
* ErrorStream.Position = 0;
* StreamReader sr = new StreamReader(ErrorStream);
* Errors = sr.ReadToEnd();
*/
}
if (!string.IsNullOrEmpty(Output))
{
L.Info("Compiler output: {0}", Output);
}
if (PhpCompilation == null)
{
op.Cancel();
}
else
{
op.Complete();
}
return(PhpCompilation);
}
}
protected override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger)
{
var parseOptions = Arguments.ParseOptions;
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];
if (Arguments.CompilationOptions.ConcurrentBuild)
{
var tasks = new Task[sourceFiles.Length];
for (int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
var treeIndex = i;
tasks[treeIndex] = Task.Run(async() =>
{
var file = sourceFiles[treeIndex];
var fileReadDiagnostics = new List <DiagnosticInfo>();
var result = await ReadFileContentAsync(file, fileReadDiagnostics, Arguments.Encoding).ConfigureAwait(false);
var content = result.Item1;
normalizedFilePaths[treeIndex] = result.Item2;
if (content == null)
{
PrintErrors(fileReadDiagnostics, consoleOutput);
fileReadDiagnostics.Clear();
hadErrors = true;
trees[treeIndex] = null;
}
else
{
trees[treeIndex] = ParseFile(parseOptions, scriptParseOptions, content, file);
}
});
}
Task.WaitAll(tasks);
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
var file = sourceFiles[i];
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, file, out normalizedFilePaths[i]);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return(null);
}
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 : this.diagnosticFormatter.RelativizeNormalizedPath(normalizedFilePath)));
trees[i] = null;
}
}
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 metadataProvider = GetMetadataProvider();
var xmlFileResolver = new LoggingXmlFileResolver(Arguments.BaseDirectory, touchedFilesLogger);
var sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray <string> .Empty, Arguments.BaseDirectory, touchedFilesLogger);
var externalReferenceResolver = GetExternalMetadataResolver(touchedFilesLogger);
MetadataReferenceResolver referenceDirectiveResolver;
var resolvedReferences = ResolveMetadataReferences(externalReferenceResolver, metadataProvider, diagnostics, assemblyIdentityComparer, touchedFilesLogger, out referenceDirectiveResolver);
if (PrintErrors(diagnostics, consoleOutput))
{
return(null);
}
var strongNameProvider = new LoggingStrongNameProvider(Arguments.KeyFileSearchPaths, touchedFilesLogger);
var compilation = CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceDirectiveResolver).
WithMetadataReferenceProvider(metadataProvider).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver));
// Print the diagnostics produced during the parsing stage and exit if there were any errors.
if (PrintErrors(compilation.GetParseDiagnostics(), consoleOutput))
{
return(null);
}
if (PrintErrors(compilation.GetDeclarationDiagnostics(), consoleOutput))
{
return(null);
}
return(compilation);
}
public override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
var parseOptions = Arguments.ParseOptions;
// 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 PhpSyntaxTree[sourceFiles.Length];
if (Arguments.CompilationOptions.ConcurrentBuild)
{
Parallel.For(0, sourceFiles.Length, new Action <int>(i =>
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger);
}));
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return(null);
}
var diagnostics = new List <DiagnosticInfo>();
var assemblyIdentityComparer = DesktopAssemblyIdentityComparer.Default;
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 referenceResolver = GetCommandLineMetadataReferenceResolver(touchedFilesLogger);
var strongNameProvider = new LoggingStrongNameProvider(Arguments.KeyFileSearchPaths, touchedFilesLogger);
var compilation = PhpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceResolver).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver)
);
return(compilation);
}
public override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
bool hadErrors = false;
var sourceFiles = Arguments.SourceFiles;
IEnumerable <PhpSyntaxTree> sourceTrees;
var resources = Enumerable.Empty <ResourceDescription>();
using (Arguments.CompilationOptions.EventSources.StartMetric("parse"))
{
// PARSE
var parseOptions = Arguments.ParseOptions;
// NOTE: order of trees is important!!
var trees = new PhpSyntaxTree[sourceFiles.Length];
var pharFiles = new List <(int index, ParsedSource phar)>();
void ProcessParsedSource(int index, ParsedSource parsed)
{
if (parsed.Manifest == null)
{
trees[index] = parsed.SyntaxTree;
}
else
{
pharFiles.Add((index, parsed));
}
}
// 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);
if (Arguments.CompilationOptions.ConcurrentBuild)
{
Parallel.For(0, sourceFiles.Length, new Action <int>(i =>
{
ProcessParsedSource(i, ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger));
}));
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
ProcessParsedSource(i, ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger));
}
}
// flattern trees and pharFiles
if (pharFiles == null || pharFiles.Count == 0)
{
sourceTrees = trees;
}
else
{
var treesList = new List <PhpSyntaxTree>(trees);
// enlist phars from the end (index)
foreach (var f in pharFiles.OrderByDescending(x => x.index))
{
treesList[f.index] = f.phar.SyntaxTree; // phar stub, may be null
treesList.InsertRange(f.index + 1, f.phar.Trees);
// add content files
if (f.phar.Resources != null)
{
resources = resources.Concat(f.phar.Resources);
}
}
sourceTrees = treesList;
}
// END PARSE
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return(null);
}
var diagnostics = new List <DiagnosticInfo>();
var assemblyIdentityComparer = DesktopAssemblyIdentityComparer.Default;
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 referenceResolver = GetCommandLineMetadataReferenceResolver(touchedFilesLogger);
var loggingFileSystem = new LoggingStrongNameFileSystem(touchedFilesLogger);
var strongNameProvider = Arguments.GetStrongNameProvider(loggingFileSystem, _tempDirectory);
var compilation = PhpCompilation.Create(
Arguments.CompilationName,
sourceTrees.WhereNotNull(),
resolvedReferences,
resources: resources,
options: Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceResolver).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver)
);
return(compilation);
}
public override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger, ErrorLogger errorLogger)
{
var parseOptions = Arguments.ParseOptions;
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];
if (Arguments.CompilationOptions.ConcurrentBuild)
{
Parallel.For(0, sourceFiles.Length, UICultureUtilities.WithCurrentUICulture<int>(i =>
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger, out normalizedFilePaths[i]);
}));
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, sourceFiles[i], errorLogger, out normalizedFilePaths[i]);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return null;
}
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 (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 = PortableShim.FileStream.Create(appConfigPath, PortableShim.FileMode.Open, PortableShim.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, touchedFilesLogger);
MetadataReferenceResolver referenceDirectiveResolver;
var resolvedReferences = ResolveMetadataReferences(diagnostics, touchedFilesLogger, out referenceDirectiveResolver);
if (ReportErrors(diagnostics, consoleOutput, errorLogger))
{
return null;
}
var strongNameProvider = new LoggingStrongNameProvider(Arguments.KeyFileSearchPaths, touchedFilesLogger);
var compilation = CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceDirectiveResolver).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver));
return compilation;
}
protected override Compilation CreateCompilation(TextWriter consoleOutput, TouchedFileLogger touchedFilesLogger)
{
var parseOptions = Arguments.ParseOptions;
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];
if (Arguments.CompilationOptions.ConcurrentBuild)
{
var tasks = new Task[sourceFiles.Length];
for(int i = 0; i < sourceFiles.Length; i++)
{
//NOTE: order of trees is important!!
var treeIndex = i;
tasks[treeIndex] = Task.Run(async () =>
{
var file = sourceFiles[treeIndex];
var fileReadDiagnostics = new List<DiagnosticInfo>();
var result = await ReadFileContentAsync(file, fileReadDiagnostics, Arguments.Encoding).ConfigureAwait(false);
var content = result.Item1;
normalizedFilePaths[treeIndex] = result.Item2;
if (content == null)
{
PrintErrors(fileReadDiagnostics, consoleOutput);
fileReadDiagnostics.Clear();
hadErrors = true;
trees[treeIndex] = null;
}
else
{
trees[treeIndex] = ParseFile(parseOptions, scriptParseOptions, content, file);
}
});
}
Task.WaitAll(tasks);
}
else
{
for (int i = 0; i < sourceFiles.Length; i++)
{
var file = sourceFiles[i];
//NOTE: order of trees is important!!
trees[i] = ParseFile(consoleOutput, parseOptions, scriptParseOptions, ref hadErrors, file, out normalizedFilePaths[i]);
}
}
// If errors had been reported in ParseFile, while trying to read files, then we should simply exit.
if (hadErrors)
{
return null;
}
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 : this.diagnosticFormatter.RelativizeNormalizedPath(normalizedFilePath)));
trees[i] = null;
}
}
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 metadataProvider = GetMetadataProvider();
var xmlFileResolver = new LoggingXmlFileResolver(Arguments.BaseDirectory, touchedFilesLogger);
var sourceFileResolver = new LoggingSourceFileResolver(ImmutableArray<string>.Empty, Arguments.BaseDirectory, touchedFilesLogger);
var externalReferenceResolver = GetExternalMetadataResolver(touchedFilesLogger);
MetadataReferenceResolver referenceDirectiveResolver;
var resolvedReferences = ResolveMetadataReferences(externalReferenceResolver, metadataProvider, diagnostics, assemblyIdentityComparer, touchedFilesLogger, out referenceDirectiveResolver);
if (PrintErrors(diagnostics, consoleOutput))
{
return null;
}
var strongNameProvider = new LoggingStrongNameProvider(Arguments.KeyFileSearchPaths, touchedFilesLogger);
var compilation = CSharpCompilation.Create(
Arguments.CompilationName,
trees.WhereNotNull(),
resolvedReferences,
Arguments.CompilationOptions.
WithMetadataReferenceResolver(referenceDirectiveResolver).
WithMetadataReferenceProvider(metadataProvider).
WithAssemblyIdentityComparer(assemblyIdentityComparer).
WithStrongNameProvider(strongNameProvider).
WithXmlReferenceResolver(xmlFileResolver).
WithSourceReferenceResolver(sourceFileResolver));
// Print the diagnostics produced during the parsing stage and exit if there were any errors.
if (PrintErrors(compilation.GetParseDiagnostics(), consoleOutput))
{
return null;
}
if (PrintErrors(compilation.GetDeclarationDiagnostics(), consoleOutput))
{
return null;
}
return compilation;
}
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)));
}