public void UpdateLocalPaths(string[] newReferenceSearchPaths, string[] newSourceSearchPaths, string newBaseDirectory)
{
var changed = false;
if (newReferenceSearchPaths != null || newBaseDirectory != null)
{
_metadataReferenceResolver = CreateFileResolver(
(newReferenceSearchPaths == null) ? _metadataReferenceResolver.SearchPaths : newReferenceSearchPaths.AsImmutable(),
newBaseDirectory ?? _metadataReferenceResolver.BaseDirectory);
changed = true;
}
if (newSourceSearchPaths != null)
{
_sourceSearchPaths = newSourceSearchPaths.AsImmutable();
changed = true;
}
if (changed)
{
var solution = _workspace.CurrentSolution;
var metadataProvider = _workspace.CurrentSolution.Services.MetadataService.GetProvider();
var oldOptions = solution.GetProjectState(_currentSubmissionProjectId).CompilationOptions;
var newOptions = oldOptions.WithMetadataReferenceResolver(new AssemblyReferenceResolver(_metadataReferenceResolver, metadataProvider));
_workspace.SetCurrentSolution(solution.WithProjectCompilationOptions(_currentSubmissionProjectId, newOptions));
}
}
private void GetReferences(
CSharpCompilerInputs compilerInputs,
MSB.Execution.ProjectInstance executedProject,
out IEnumerable <MetadataReference> metadataReferences,
out IEnumerable <AnalyzerReference> analyzerReferences)
{
// use command line parser to do reference translation same as command line compiler
var args = new List <string>();
if (compilerInputs.LibPaths != null && compilerInputs.LibPaths.Count > 0)
{
args.Add("/lib:\"" + string.Join(";", compilerInputs.LibPaths) + "\"");
}
foreach (var mr in compilerInputs.References)
{
var filePath = GetDocumentFilePath(mr);
var aliases = GetAliases(mr);
if (aliases.IsDefaultOrEmpty)
{
args.Add("/r:\"" + filePath + "\"");
}
else
{
foreach (var alias in aliases)
{
args.Add("/r:" + alias + "=\"" + filePath + "\"");
}
}
}
foreach (var ar in compilerInputs.AnalyzerReferences)
{
var filePath = GetDocumentFilePath(ar);
args.Add("/a:\"" + filePath + "\"");
}
if (compilerInputs.NoStandardLib)
{
args.Add("/nostdlib");
}
var commandLineParser = CSharpCommandLineParser.Default;
var commandLineArgs = commandLineParser.Parse(args, executedProject.Directory, RuntimeEnvironment.GetRuntimeDirectory());
var resolver = new MetadataFileReferenceResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory);
metadataReferences = commandLineArgs.ResolveMetadataReferences(new AssemblyReferenceResolver(resolver, _metadataService.GetProvider()));
var analyzerLoader = _analyzerService.GetLoader();
foreach (var path in commandLineArgs.AnalyzerReferences.Select(r => r.FilePath))
{
analyzerLoader.AddDependencyLocation(path);
}
analyzerReferences = commandLineArgs.ResolveAnalyzerReferences(analyzerLoader);
}
internal DesktopMetadataReferenceResolver(
MetadataFileReferenceResolver pathResolver,
NuGetPackageResolver packageResolver,
GacFileResolver gacFileResolver)
{
_pathResolver = pathResolver;
_packageResolver = packageResolver;
_gacFileResolver = gacFileResolver;
}
/// <summary>
/// Creates a new <see cref="ScriptOptions"/> with the reference resolver specified.
/// </summary>
internal ScriptOptions WithReferenceResolver(MetadataFileReferenceResolver resolver)
{
if (resolver == _referenceResolver.PathResolver)
{
return(this);
}
return(With(resolver: new AssemblyReferenceResolver(resolver, _referenceResolver.Provider)));
}
internal DesktopMetadataReferenceResolver(
MetadataFileReferenceResolver pathResolver,
NuGetPackageResolver packageResolver,
GacFileResolver gacFileResolver)
{
_pathResolver = pathResolver;
_packageResolver = packageResolver;
_gacFileResolver = gacFileResolver;
}
public void ResolvePath_Order()
{
var dir = Temp.CreateDirectory();
var dir1 = dir.CreateDirectory("dir1");
var dir2 = dir.CreateDirectory("dir2");
var f1 = dir1.CreateFile("f.dll").Path;
var f2 = dir2.CreateFile("f.dll").Path;
var resolver = new MetadataFileReferenceResolver(
ImmutableArray.Create(dir1.Path, dir2.Path),
baseDirectory: null);
var path = resolver.ResolveReference("f.dll", null);
Assert.Equal(f1, path, StringComparer.OrdinalIgnoreCase);
}
public CSharpCompilationOptions CreateCSharpCompilationOptions()
{
string moduleName = null;
string mainTypeName = null;
string scriptClassName = null;
IEnumerable <string> usings = null;
OptimizationLevel optimizationLevel = OptimizationLevel.Debug;
bool checkOverflow = false;
bool allowUnsafe = false;
string cryptoKeyContainer = null;
string cryptoKeyFile = null;
bool? delaySign = null;
int fileAlignment = 0;
ulong baseAddress = 0;
Platform platform = 0;
ReportDiagnostic generalDiagnosticOption = 0;
int warningLevel = 0;
IEnumerable <KeyValuePair <string, ReportDiagnostic> > specificDiagnosticOptions = null;
bool highEntropyVirtualAddressSpace = false;
SubsystemVersion subsystemVersion = default(SubsystemVersion);
string runtimeMetadataVersion = null;
bool concurrentBuild = false;
XmlReferenceResolver xmlReferenceResolver = new XmlFileResolver(null);
SourceReferenceResolver sourceReferenceResolver = new SourceFileResolver(ImmutableArray <string> .Empty, null);
MetadataReferenceResolver metadataReferenceResolver = new MetadataFileReferenceResolver(ImmutableArray <string> .Empty, null);
MetadataReferenceProvider metadataReferenceProvider = MetadataFileReferenceProvider.Default; // Currently uses reference equality
AssemblyIdentityComparer assemblyIdentityComparer = AssemblyIdentityComparer.Default; // Currently uses reference equality
StrongNameProvider strongNameProvider = new DesktopStrongNameProvider();
MetadataImportOptions metadataImportOptions = 0;
ImmutableArray <string> features = ImmutableArray <string> .Empty;
return(new CSharpCompilationOptions(OutputKind.ConsoleApplication, moduleName, mainTypeName, scriptClassName, usings,
optimizationLevel, checkOverflow, allowUnsafe, cryptoKeyContainer, cryptoKeyFile, delaySign, fileAlignment, baseAddress,
platform, generalDiagnosticOption, warningLevel, specificDiagnosticOptions, highEntropyVirtualAddressSpace,
subsystemVersion, runtimeMetadataVersion, concurrentBuild, xmlReferenceResolver, sourceReferenceResolver, metadataReferenceResolver, metadataReferenceProvider,
assemblyIdentityComparer, strongNameProvider, metadataImportOptions, features));
}
public void UpdateLocalPaths(string[] newReferenceSearchPaths, string[] newSourceSearchPaths, string newBaseDirectory)
{
var changed = false;
if (newReferenceSearchPaths != null || newBaseDirectory != null)
{
_metadataReferenceResolver = CreateFileResolver(
(newReferenceSearchPaths == null) ? _metadataReferenceResolver.SearchPaths : newReferenceSearchPaths.AsImmutable(),
newBaseDirectory ?? _metadataReferenceResolver.BaseDirectory);
changed = true;
}
if (newSourceSearchPaths != null)
{
_sourceSearchPaths = newSourceSearchPaths.AsImmutable();
changed = true;
}
if (changed)
{
var solution = _workspace.CurrentSolution;
var metadataProvider = _workspace.CurrentSolution.Services.MetadataService.GetProvider();
var oldOptions = solution.GetProjectState(_currentSubmissionProjectId).CompilationOptions;
var newOptions = oldOptions.WithMetadataReferenceResolver(new AssemblyReferenceResolver(_metadataReferenceResolver, metadataProvider));
_workspace.SetCurrentSolution(solution.WithProjectCompilationOptions(_currentSubmissionProjectId, newOptions));
}
}
/// <summary>
/// Invoked by <see cref="InteractiveHost"/> when a new process is being started.
/// </summary>
private void ProcessStarting(InteractiveHostOptions options)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke(new Action(() => ProcessStarting(options)));
return;
}
// Freeze all existing classifications and then clear the list of
// submission buffers we have.
FreezeClassifications();
_submissionBuffers.Clear();
// We always start out empty
_workspace.ClearSolution();
_currentSubmissionProjectId = null;
_previousSubmissionProjectId = null;
var metadataService = _workspace.CurrentSolution.Services.MetadataService;
ImmutableArray<string> referencePaths;
// reset configuration:
if (File.Exists(_responseFilePath))
{
// The base directory for relative paths is the directory that contains the .rsp file.
// Note that .rsp files included by this .rsp file will share the base directory (Dev10 behavior of csc/vbc).
var rspArguments = this.CommandLineParser.Parse(new[] { "@" + _responseFilePath }, Path.GetDirectoryName(_responseFilePath), RuntimeEnvironment.GetRuntimeDirectory(), null /* TODO: pass a valid value*/);
referencePaths = rspArguments.ReferencePaths;
// the base directory for references specified in the .rsp file is the .rsp file directory:
var rspMetadataReferenceResolver = CreateFileResolver(referencePaths, rspArguments.BaseDirectory);
var metadataProvider = metadataService.GetProvider();
// ignore unresolved references, they will be reported in the interactive window:
var rspReferences = rspArguments.ResolveMetadataReferences(new AssemblyReferenceResolver(rspMetadataReferenceResolver, metadataProvider))
.Where(r => !(r is UnresolvedMetadataReference));
var interactiveHelpersRef = metadataService.GetReference(typeof(Script).Assembly.Location, MetadataReferenceProperties.Assembly);
var interactiveHostObjectRef = metadataService.GetReference(typeof(InteractiveHostObject).Assembly.Location, MetadataReferenceProperties.Assembly);
_references = ImmutableHashSet.Create<MetadataReference>(
interactiveHelpersRef,
interactiveHostObjectRef)
.Union(rspReferences);
// we need to create projects for these:
_rspSourceFiles = rspArguments.SourceFiles;
}
else
{
var mscorlibRef = metadataService.GetReference(typeof(object).Assembly.Location, MetadataReferenceProperties.Assembly);
_references = ImmutableHashSet.Create<MetadataReference>(mscorlibRef);
_rspSourceFiles = ImmutableArray.Create<CommandLineSourceFile>();
referencePaths = ScriptOptions.Default.SearchPaths;
}
// reset search paths, working directory:
_metadataReferenceResolver = CreateFileResolver(referencePaths, _initialWorkingDirectory);
_sourceSearchPaths = InteractiveHost.Service.DefaultSourceSearchPaths;
// create the first submission project in the workspace after reset:
if (_currentSubmissionBuffer != null)
{
AddSubmission(_currentTextView, _currentSubmissionBuffer, this.LanguageName);
}
}
public void SetReferenceSearchPaths(ImmutableArray <string> paths)
{
MetadataFileReferenceResolver.ValidateSearchPaths(paths, "paths");
_options = _options.WithSearchPaths(paths);
}
/// <summary>
/// Invoked by <see cref="InteractiveHost"/> when a new process is being started.
/// </summary>
private void ProcessStarting(bool initialize)
{
if (!Dispatcher.CheckAccess())
{
Dispatcher.BeginInvoke(new Action(() => ProcessStarting(initialize)));
return;
}
// Freeze all existing classifications and then clear the list of
// submission buffers we have.
FreezeClassifications();
_submissionBuffers.Clear();
// We always start out empty
_workspace.ClearSolution();
_currentSubmissionProjectId = null;
_previousSubmissionProjectId = null;
var metadataService = _workspace.CurrentSolution.Services.MetadataService;
ImmutableArray <string> referencePaths;
if (initialize && File.Exists(_responseFilePath))
{
// The base directory for relative paths is the directory that contains the .rsp file.
// Note that .rsp files included by this .rsp file will share the base directory (Dev10 behavior of csc/vbc).
var rspArguments = this.CommandLineParser.Parse(new[] { "@" + _responseFilePath }, Path.GetDirectoryName(_responseFilePath), RuntimeEnvironment.GetRuntimeDirectory(), null /* TODO: pass a valid value*/);
referencePaths = rspArguments.ReferencePaths;
// the base directory for references specified in the .rsp file is the .rsp file directory:
var rspMetadataReferenceResolver = CreateFileResolver(referencePaths, rspArguments.BaseDirectory);
var metadataProvider = metadataService.GetProvider();
// ignore unresolved references, they will be reported in the interactive window:
var rspReferences = rspArguments.ResolveMetadataReferences(new AssemblyReferenceResolver(rspMetadataReferenceResolver, metadataProvider))
.Where(r => !(r is UnresolvedMetadataReference));
var interactiveHelpersRef = metadataService.GetReference(typeof(Script).Assembly.Location, MetadataReferenceProperties.Assembly);
var interactiveHostObjectRef = metadataService.GetReference(typeof(InteractiveHostObject).Assembly.Location, MetadataReferenceProperties.Assembly);
_references = ImmutableHashSet.Create <MetadataReference>(
interactiveHelpersRef,
interactiveHostObjectRef)
.Union(rspReferences);
// we need to create projects for these:
_rspSourceFiles = rspArguments.SourceFiles;
}
else
{
var mscorlibRef = metadataService.GetReference(typeof(object).Assembly.Location, MetadataReferenceProperties.Assembly);
_references = ImmutableHashSet.Create <MetadataReference>(mscorlibRef);
_rspSourceFiles = ImmutableArray.Create <CommandLineSourceFile>();
referencePaths = ScriptOptions.Default.SearchPaths;
}
// reset search paths, working directory:
_metadataReferenceResolver = CreateFileResolver(referencePaths, _initialWorkingDirectory);
_sourceSearchPaths = InteractiveHost.Service.DefaultSourceSearchPaths;
// create the first submission project in the workspace after reset:
if (_currentSubmissionBuffer != null)
{
AddSubmission(_currentTextView, _currentSubmissionBuffer, this.LanguageName);
}
}
public void ResolvePath_Order()
{
var dir = Temp.CreateDirectory();
var dir1 = dir.CreateDirectory("dir1");
var dir2 = dir.CreateDirectory("dir2");
var f1 = dir1.CreateFile("f.dll").Path;
var f2 = dir2.CreateFile("f.dll").Path;
var resolver = new MetadataFileReferenceResolver(
ImmutableArray.Create(dir1.Path, dir2.Path),
baseDirectory: null);
var path = resolver.ResolveReference("f.dll", null);
Assert.Equal(f1, path, StringComparer.OrdinalIgnoreCase);
}
private void GetReferences(VisualBasicProjectFileLoader.VisualBasicProjectFile.VisualBasicCompilerInputs compilerInputs, ProjectInstance executedProject, ref IEnumerable <MetadataReference> metadataReferences, ref IEnumerable <AnalyzerReference> analyzerReferences)
{
// use command line parser to compute references using common logic
List <string> list = new List <string>();
if (compilerInputs.LibPaths != null && compilerInputs.LibPaths.Count <string>() > 0)
{
list.Add("/libpath:\"" + string.Join(";", compilerInputs.LibPaths) + "\"");
}
// metadata references
foreach (var current in compilerInputs.References)
{
string documentFilePath = base.GetDocumentFilePath(current);
list.Add("/r:\"" + documentFilePath + "\"");
}
// analyzer references
foreach (var current in compilerInputs.AnalyzerReferences)
{
string documentFilePath2 = base.GetDocumentFilePath(current);
list.Add("/a:\"" + documentFilePath2 + "\"");
}
if (compilerInputs.NoStandardLib)
{
list.Add("/nostdlib");
}
if (!string.IsNullOrEmpty(compilerInputs.VbRuntime))
{
if (compilerInputs.VbRuntime == "Default")
{
list.Add("/vbruntime+");
}
else if (compilerInputs.VbRuntime == "Embed")
{
list.Add("/vbruntime*");
}
else if (compilerInputs.VbRuntime == "None")
{
list.Add("/vbruntime-");
}
else
{
list.Add("/vbruntime: " + compilerInputs.VbRuntime);
}
}
if (!string.IsNullOrEmpty(compilerInputs.SdkPath))
{
list.Add("/sdkpath:" + compilerInputs.SdkPath);
}
CommandLineArguments commandLineArguments = this._commandLineArgumentsFactory.CreateCommandLineArguments(list, executedProject.Directory, false, RuntimeEnvironment.GetRuntimeDirectory());
MetadataFileReferenceResolver pathResolver = new MetadataFileReferenceResolver(commandLineArguments.ReferencePaths, commandLineArguments.BaseDirectory);
metadataReferences = commandLineArguments.ResolveMetadataReferences(new AssemblyReferenceResolver(pathResolver, this._metadataService.GetProvider()));
IAnalyzerAssemblyLoader loader = this._analyzerService.GetLoader();
foreach (var path in commandLineArguments.AnalyzerReferences.Select((r) => r.FilePath))
{
loader.AddDependencyLocation(path);
}
analyzerReferences = commandLineArguments.ResolveAnalyzerReferences(loader);
}
private async Task<ProjectId> LoadProjectAsync(string projectFilePath, IProjectFileLoader loader, bool preferMetadata, LoadState loadedProjects, CancellationToken cancellationToken)
{
Debug.Assert(projectFilePath != null);
Debug.Assert(loader != null);
var projectId = loadedProjects.GetOrCreateProjectId(projectFilePath);
var projectName = Path.GetFileNameWithoutExtension(projectFilePath);
var projectFile = await loader.LoadProjectFileAsync(projectFilePath, _properties, cancellationToken).ConfigureAwait(false);
var projectFileInfo = await projectFile.GetProjectFileInfoAsync(cancellationToken).ConfigureAwait(false);
var projectDirectory = Path.GetDirectoryName(projectFilePath);
var outputFilePath = projectFileInfo.OutputFilePath;
var outputDirectory = Path.GetDirectoryName(outputFilePath);
VersionStamp version;
if (!string.IsNullOrEmpty(projectFilePath) && File.Exists(projectFilePath))
{
version = VersionStamp.Create(File.GetLastWriteTimeUtc(projectFilePath));
}
else
{
version = VersionStamp.Create();
}
// translate information from command line args
var commandLineParser = _workspace.Services.GetLanguageServices(loader.Language).GetService<ICommandLineParserService>();
var metadataService = _workspace.Services.GetService<IMetadataService>();
var analyzerService = _workspace.Services.GetService<IAnalyzerService>();
var commandLineArgs = commandLineParser.Parse(
arguments: projectFileInfo.CommandLineArgs,
baseDirectory: projectDirectory,
isInteractive: false,
sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory());
var resolver = new MetadataFileReferenceResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory);
var metadataReferences = commandLineArgs.ResolveMetadataReferences(new AssemblyReferenceResolver(resolver, metadataService.GetProvider()));
var analyzerLoader = analyzerService.GetLoader();
foreach (var path in commandLineArgs.AnalyzerReferences.Select(r => r.FilePath))
{
analyzerLoader.AddDependencyLocation(path);
}
var analyzerReferences = commandLineArgs.ResolveAnalyzerReferences(analyzerLoader);
var defaultEncoding = commandLineArgs.Encoding;
// docs & additional docs
var docFileInfos = projectFileInfo.Documents.ToImmutableArrayOrEmpty();
var additionalDocFileInfos = projectFileInfo.AdditionalDocuments.ToImmutableArrayOrEmpty();
// check for duplicate documents
var allDocFileInfos = docFileInfos.AddRange(additionalDocFileInfos);
CheckDocuments(allDocFileInfos, projectFilePath, projectId);
var docs = new List<DocumentInfo>();
foreach (var docFileInfo in docFileInfos)
{
string name;
ImmutableArray<string> folders;
GetDocumentNameAndFolders(docFileInfo.LogicalPath, out name, out folders);
docs.Add(DocumentInfo.Create(
DocumentId.CreateNewId(projectId, debugName: docFileInfo.FilePath),
name,
folders,
projectFile.GetSourceCodeKind(docFileInfo.FilePath),
new FileTextLoader(docFileInfo.FilePath, defaultEncoding),
docFileInfo.FilePath,
docFileInfo.IsGenerated));
}
var additionalDocs = new List<DocumentInfo>();
foreach (var docFileInfo in additionalDocFileInfos)
{
string name;
ImmutableArray<string> folders;
GetDocumentNameAndFolders(docFileInfo.LogicalPath, out name, out folders);
additionalDocs.Add(DocumentInfo.Create(
DocumentId.CreateNewId(projectId, debugName: docFileInfo.FilePath),
name,
folders,
SourceCodeKind.Regular,
new FileTextLoader(docFileInfo.FilePath, defaultEncoding),
docFileInfo.FilePath,
docFileInfo.IsGenerated));
}
// project references
var resolvedReferences = await this.ResolveProjectReferencesAsync(
projectId, projectFilePath, projectFileInfo.ProjectReferences, preferMetadata, loadedProjects, cancellationToken).ConfigureAwait(false);
// add metadata references for project refs converted to metadata refs
metadataReferences = metadataReferences.Concat(resolvedReferences.MetadataReferences);
// if the project file loader couldn't figure out an assembly name, make one using the project's file path.
var assemblyName = commandLineArgs.CompilationName;
if (string.IsNullOrWhiteSpace(assemblyName))
{
assemblyName = Path.GetFileNameWithoutExtension(projectFilePath);
// if this is still unreasonable, use a fixed name.
if (string.IsNullOrWhiteSpace(assemblyName))
{
assemblyName = "assembly";
}
}
// make sure that doc-comments at least get parsed.
var parseOptions = commandLineArgs.ParseOptions;
if (parseOptions.DocumentationMode == DocumentationMode.None)
{
parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Parse);
}
// add all the extra options that are really behavior overrides
var compOptions = commandLineArgs.CompilationOptions
.WithXmlReferenceResolver(new XmlFileResolver(projectDirectory))
.WithSourceReferenceResolver(new SourceFileResolver(ImmutableArray<string>.Empty, projectDirectory))
.WithMetadataReferenceResolver(
new AssemblyReferenceResolver(
new MetadataFileReferenceResolver(ImmutableArray<string>.Empty, projectDirectory),
MetadataFileReferenceProvider.Default))
.WithStrongNameProvider(new DesktopStrongNameProvider(ImmutableArray.Create(projectDirectory, outputFilePath)))
.WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default);
loadedProjects.Add(
ProjectInfo.Create(
projectId,
version,
projectName,
assemblyName,
loader.Language,
projectFilePath,
outputFilePath,
compilationOptions: compOptions,
parseOptions: parseOptions,
documents: docs,
projectReferences: resolvedReferences.ProjectReferences,
metadataReferences: metadataReferences,
analyzerReferences: analyzerReferences,
additionalDocuments: additionalDocs,
isSubmission: false,
hostObjectType: null));
return projectId;
}
private void GetReferences(VisualBasicProjectFileLoader.VisualBasicProjectFile.VisualBasicCompilerInputs compilerInputs, ProjectInstance executedProject, ref IEnumerable<MetadataReference> metadataReferences, ref IEnumerable<AnalyzerReference> analyzerReferences)
{
// use command line parser to compute references using common logic
List<string> list = new List<string>();
if (compilerInputs.LibPaths != null && compilerInputs.LibPaths.Count<string>() > 0)
{
list.Add("/libpath:\"" + string.Join(";", compilerInputs.LibPaths) + "\"");
}
// metadata references
foreach (var current in compilerInputs.References)
{
if (!IsProjectReferenceOutputAssembly(current))
{
string documentFilePath = base.GetDocumentFilePath(current);
list.Add("/r:\"" + documentFilePath + "\"");
}
}
// analyzer references
foreach (var current in compilerInputs.AnalyzerReferences)
{
string documentFilePath2 = base.GetDocumentFilePath(current);
list.Add("/a:\"" + documentFilePath2 + "\"");
}
if (compilerInputs.NoStandardLib)
{
list.Add("/nostdlib");
}
if (!string.IsNullOrEmpty(compilerInputs.VbRuntime))
{
if (compilerInputs.VbRuntime == "Default")
{
list.Add("/vbruntime+");
}
else if (compilerInputs.VbRuntime == "Embed")
{
list.Add("/vbruntime*");
}
else if (compilerInputs.VbRuntime == "None")
{
list.Add("/vbruntime-");
}
else
{
list.Add("/vbruntime: " + compilerInputs.VbRuntime);
}
}
if (!string.IsNullOrEmpty(compilerInputs.SdkPath))
{
list.Add("/sdkpath:" + compilerInputs.SdkPath);
}
CommandLineArguments commandLineArguments = _commandLineArgumentsFactory.CreateCommandLineArguments(list, executedProject.Directory, false, RuntimeEnvironment.GetRuntimeDirectory());
MetadataFileReferenceResolver pathResolver = new MetadataFileReferenceResolver(commandLineArguments.ReferencePaths, commandLineArguments.BaseDirectory);
metadataReferences = commandLineArguments.ResolveMetadataReferences(new AssemblyReferenceResolver(pathResolver, _metadataService.GetProvider()));
IAnalyzerAssemblyLoader loader = _analyzerService.GetLoader();
foreach (var path in commandLineArguments.AnalyzerReferences.Select((r) => r.FilePath))
{
loader.AddDependencyLocation(path);
}
analyzerReferences = commandLineArguments.ResolveAnalyzerReferences(loader);
}
public override bool Execute()
{
_cancellationTokenSource = new CancellationTokenSource();
var directory = Path.GetDirectoryName(ProjectFile);
var arguments = new List <string>();
arguments.Add("/define:\"" + DefineConstants + "\"");
arguments.Add("/nowarn:\"" + DisabledWarnings + "\"");
if (!string.IsNullOrEmpty(MainEntryPoint))
{
arguments.Add("/main:\"" + MainEntryPoint + "\"");
}
arguments.Add("/target:" + TargetType);
arguments.Add("/moduleassemblyname:\"" + ModuleAssemblyName + "\"");
if (TreatWarningsAsErrors)
{
arguments.Add("/warnaserror");
}
arguments.Add("/warn:\"" + WarningLevel + "\"");
arguments.Add("/warnaserror+:\"" + WarningsAsErrors + "\"");
arguments.Add("/warnaserror-:\"" + WarningsNotAsErrors + "\"");
foreach (var mr in References)
{
var filePath = Path.Combine(directory, mr.ItemSpec);
var aliases = GetAliases(mr);
if (aliases.IsDefaultOrEmpty)
{
arguments.Add("/reference:\"" + filePath + "\"");
}
else
{
foreach (var alias in aliases)
{
arguments.Add("/reference:" + alias + "=\"" + filePath + "\"");
}
}
}
try
{
ImmutableArray.Create(1, 2, 3);
var config = new LoggingConfiguration();
config.AddTarget("msbuild", new MSBuildTarget(Log)
{
Layout = "${longdate} ${level} ${callsite} - ${message} ${exception:format=ToString}"
});
config.AddRule(LogLevel.Trace, LogLevel.Fatal, "msbuild");
LogManager.Configuration = config;
var args = CSharpCommandLineParser.Default.Parse(arguments, directory, RuntimeEnvironment.GetRuntimeDirectory());
var resolver = new MetadataFileReferenceResolver(directory);
var references = args.ResolveMetadataReferences(resolver);
var input = new PhaseCompilerInput
{
ProjectFile = ProjectFile,
CompilationOptions = args.CompilationOptions,
ParseOptions = args.ParseOptions,
SourceFiles = Sources.Select(s => Path.Combine(directory, s.ItemSpec)).ToArray(),
ReferencedAssemblies = references,
Platform = Platform,
Configuration = Configuration
};
var compiler = new PhaseCompiler(input);
compiler.CompileAsync(_cancellationTokenSource.Token).Wait();
return(true);
}
catch (Exception e)
{
Log.LogError(e.Message);
if (Debugger.IsAttached)
{
Debugger.Break();
}
return(false);
}
}
