public void CompileTempPE(string pszOutputFileName, int sourceCount, string[] fileNames, string[] fileContents, int optionCount, string[] optionNames, object[] optionValues)
{
var baseDirectory = Path.GetDirectoryName(pszOutputFileName);
var parsedArguments = ParseCommandLineArguments(baseDirectory, optionNames, optionValues);
Contract.ThrowIfFalse(fileNames.Length == fileContents.Length);
var trees = new List<SyntaxTree>(capacity: sourceCount);
for (int i = 0; i < fileNames.Length; i++)
{
// create a parse tree w/o encoding - the tree won't be used to emit PDBs
trees.Add(SyntaxFactory.ParseSyntaxTree(fileContents[i], parsedArguments.ParseOptions, fileNames[i]));
}
// TODO (tomat): Revisit compilation options: App.config, strong name, search paths, etc? (bug #869604)
// TODO (tomat): move resolver initialization (With* methods below) to CommandLineParser.Parse
var metadataProvider = _workspace.Services.GetService<IMetadataService>().GetProvider();
var metadataResolver = new AssemblyReferenceResolver(MetadataFileReferenceResolver.Default, metadataProvider);
var compilation = CSharpCompilation.Create(
Path.GetFileName(pszOutputFileName),
trees,
parsedArguments.ResolveMetadataReferences(metadataResolver),
parsedArguments.CompilationOptions
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default)
.WithSourceReferenceResolver(SourceFileResolver.Default)
.WithXmlReferenceResolver(XmlFileResolver.Default)
.WithMetadataReferenceResolver(metadataResolver));
compilation.Emit(pszOutputFileName);
}
private ScriptOptions(
ImmutableArray<MetadataReference> references,
ImmutableArray<string> namespaces,
AssemblyReferenceResolver referenceResolver,
bool isInteractive)
{
_references = references;
_namespaces = namespaces;
_referenceResolver = referenceResolver;
_isInteractive = isInteractive;
}
protected override CSharpCompilationOptions CreateCompilationOptions()
{
IDictionary<string, ReportDiagnostic> ruleSetSpecificDiagnosticOptions = null;
// Get options from the ruleset file, if any, first. That way project-specific
// options can override them.
ReportDiagnostic? ruleSetGeneralDiagnosticOption = null;
if (this.ruleSet != null)
{
ruleSetGeneralDiagnosticOption = this.ruleSet.GetGeneralDiagnosticOption();
ruleSetSpecificDiagnosticOptions = new Dictionary<string, ReportDiagnostic>(this.ruleSet.GetSpecificDiagnosticOptions());
}
else
{
ruleSetSpecificDiagnosticOptions = new Dictionary<string, ReportDiagnostic>();
}
UpdateRuleSetError(ruleSet);
ReportDiagnostic generalDiagnosticOption;
var warningsAreErrors = GetNullableBooleanOption(CompilerOptions.OPTID_WARNINGSAREERRORS);
if (warningsAreErrors.HasValue)
{
generalDiagnosticOption = warningsAreErrors.Value ? ReportDiagnostic.Error : ReportDiagnostic.Default;
}
else if (ruleSetGeneralDiagnosticOption.HasValue)
{
generalDiagnosticOption = ruleSetGeneralDiagnosticOption.Value;
}
else
{
generalDiagnosticOption = ReportDiagnostic.Default;
}
// Start with the rule set options
IDictionary<string, ReportDiagnostic> diagnosticOptions = new Dictionary<string, ReportDiagnostic>(ruleSetSpecificDiagnosticOptions);
// Update the specific options based on the general settings
if (warningsAreErrors.HasValue && warningsAreErrors.Value == true)
{
foreach (var pair in ruleSetSpecificDiagnosticOptions)
{
if (pair.Value == ReportDiagnostic.Warn)
{
diagnosticOptions[pair.Key] = ReportDiagnostic.Error;
}
}
}
// Update the specific options based on the specific settings
foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_WARNASERRORLIST))
{
diagnosticOptions[diagnosticID] = ReportDiagnostic.Error;
}
foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_WARNNOTASERRORLIST))
{
ReportDiagnostic ruleSetOption;
if (ruleSetSpecificDiagnosticOptions.TryGetValue(diagnosticID, out ruleSetOption))
{
diagnosticOptions[diagnosticID] = ruleSetOption;
}
else
{
diagnosticOptions[diagnosticID] = ReportDiagnostic.Default;
}
}
foreach (var diagnosticID in ParseWarningCodes(CompilerOptions.OPTID_NOWARNLIST))
{
diagnosticOptions[diagnosticID] = ReportDiagnostic.Suppress;
}
Platform platform;
if (!Enum.TryParse(GetStringOption(CompilerOptions.OPTID_PLATFORM, ""), ignoreCase: true, result: out platform))
{
platform = Platform.AnyCpu;
}
int warningLevel;
if (!int.TryParse(GetStringOption(CompilerOptions.OPTID_WARNINGLEVEL, defaultValue: ""), out warningLevel))
{
warningLevel = 4;
}
string projectDirectory = this.ContainingDirectoryPathOpt;
// TODO: #r support, should it include bin path?
var referenceSearchPaths = ImmutableArray<string>.Empty;
// TODO: #load support
var sourceSearchPaths = ImmutableArray<string>.Empty;
MetadataReferenceResolver referenceResolver;
if (this.Workspace != null)
{
referenceResolver = new AssemblyReferenceResolver(
new MetadataFileReferenceResolver(referenceSearchPaths, projectDirectory),
this.Workspace.CurrentSolution.Services.MetadataService.GetProvider());
}
else
{
// can only happen in tests
referenceResolver = null;
}
// TODO: appConfigPath: GetFilePathOption(CompilerOptions.OPTID_FUSIONCONFIG), bug #869604
return new CSharpCompilationOptions(
allowUnsafe: GetBooleanOption(CompilerOptions.OPTID_UNSAFE),
checkOverflow: GetBooleanOption(CompilerOptions.OPTID_CHECKED),
concurrentBuild: false,
cryptoKeyContainer: GetStringOption(CompilerOptions.OPTID_KEYNAME, defaultValue: null),
cryptoKeyFile: GetFilePathRelativeOption(CompilerOptions.OPTID_KEYFILE),
delaySign: GetNullableBooleanOption(CompilerOptions.OPTID_DELAYSIGN),
generalDiagnosticOption: generalDiagnosticOption,
mainTypeName: _mainTypeName,
moduleName: GetStringOption(CompilerOptions.OPTID_MODULEASSEMBLY, defaultValue: null),
optimizationLevel: GetBooleanOption(CompilerOptions.OPTID_OPTIMIZATIONS) ? OptimizationLevel.Release : OptimizationLevel.Debug,
outputKind: _outputKind,
platform: platform,
specificDiagnosticOptions: diagnosticOptions,
warningLevel: warningLevel,
xmlReferenceResolver: new XmlFileResolver(projectDirectory),
sourceReferenceResolver: new SourceFileResolver(sourceSearchPaths, projectDirectory),
metadataReferenceResolver: referenceResolver,
assemblyIdentityComparer: DesktopAssemblyIdentityComparer.Default,
strongNameProvider: new DesktopStrongNameProvider(GetStrongNameKeyPaths()));
}
public bool Equals(AssemblyReferenceResolver other)
{
return(other != null &&
PathResolver.Equals(other.PathResolver) &&
ReferenceEquals(Provider, other.Provider));
}
public bool Equals(AssemblyReferenceResolver other)
{
return other != null
&& PathResolver.Equals(other.PathResolver)
&& ReferenceEquals(Provider, other.Provider);
}