private ProjectFileInfo CreateProjectFileInfo(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject)
{
string projectDirectory = executedProject.Directory;
if (!projectDirectory.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.OrdinalIgnoreCase))
{
projectDirectory += Path.DirectorySeparatorChar;
}
var docs = compilerInputs.Sources
.Where(s => !Path.GetFileName(s.ItemSpec).StartsWith("TemporaryGeneratedFile_"))
.Select(s => MakeDocumentFileInfo(projectDirectory, s))
.ToImmutableArray();
IEnumerable<MetadataReference> metadataRefs;
IEnumerable<AnalyzerReference> analyzerRefs;
this.GetReferences(compilerInputs, executedProject, out metadataRefs, out analyzerRefs);
var outputPath = Path.Combine(this.GetOutputDirectory(), compilerInputs.OutputFileName);
var assemblyName = this.GetAssemblyName();
return new ProjectFileInfo(
this.Guid,
outputPath,
assemblyName,
compilerInputs.CompilationOptions,
compilerInputs.ParseOptions,
docs,
this.GetProjectReferences(executedProject),
metadataRefs,
analyzerRefs);
}
private ProjectFileInfo CreateProjectFileInfo(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject)
{
string projectDirectory = executedProject.Directory;
string directorySeparator = Path.DirectorySeparatorChar.ToString();
if (!projectDirectory.EndsWith(directorySeparator, StringComparison.OrdinalIgnoreCase))
{
projectDirectory += directorySeparator;
}
var docs = compilerInputs.Sources
.Where(s => !Path.GetFileName(s.ItemSpec).StartsWith("TemporaryGeneratedFile_", StringComparison.Ordinal))
.Select(s => MakeDocumentFileInfo(projectDirectory, s))
.ToImmutableArray();
var additionalDocs = compilerInputs.AdditionalSources
.Select(s => MakeDocumentFileInfo(projectDirectory, s))
.ToImmutableArray();
var outputPath = Path.Combine(this.GetOutputDirectory(), compilerInputs.OutputFileName);
var assemblyName = this.GetAssemblyName();
return new ProjectFileInfo(
outputPath,
assemblyName,
compilerInputs.CommandLineArgs,
docs,
additionalDocs,
this.GetProjectReferences(executedProject));
}
private ProjectFileInfo CreateProjectFileInfo(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject)
{
string projectDirectory = executedProject.Directory;
if (!projectDirectory.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.OrdinalIgnoreCase))
{
projectDirectory += Path.DirectorySeparatorChar;
}
var docs = compilerInputs.Sources
.Where(s => !Path.GetFileName(s.ItemSpec).StartsWith("TemporaryGeneratedFile_"))
.Select(s => MakeDocumentFileInfo(projectDirectory, s))
.ToImmutableList();
var metadataRefs = compilerInputs.References.SelectMany(r => MakeMetadataInfo(r));
var analyzerRefs = compilerInputs.AnalyzerReferences.Select(r => new AnalyzerFileReference(GetDocumentFilePath(r)));
if (!compilerInputs.NoStandardLib)
{
var mscorlibPath = typeof(object).Assembly.Location;
metadataRefs = metadataRefs.Concat(new[] { new MetadataInfo(mscorlibPath) });
}
return new ProjectFileInfo(
this.Guid,
this.GetTargetPath(),
this.GetAssemblyName(),
compilerInputs.CompilationOptions,
compilerInputs.ParseOptions,
docs,
this.GetProjectReferences(executedProject),
metadataRefs,
analyzerRefs,
appConfigPath: compilerInputs.AppConfigPath);
}
public VisualBasicProjectFile(VisualBasicProjectFileLoader loader, MSB.Evaluation.Project loadedProject, IMetadataService metadataService, IAnalyzerService analyzerService) : base(loader, loadedProject)
{
_metadataService = metadataService;
_analyzerService = analyzerService;
_hostBuildDataFactory = loader.LanguageServices.GetService<IHostBuildDataFactory>();
_commandLineArgumentsFactory = loader.LanguageServices.GetService<ICommandLineArgumentsFactoryService>();
}
public CSharpProjectFile(CSharpProjectFileLoader loader, MSB.Evaluation.Project project, IMetadataService metadataService, IAnalyzerService analyzerService)
: base(loader, project)
{
_metadataService = metadataService;
_analyzerService = analyzerService;
_msbuildHost = loader.MSBuildHost;
_commandLineArgumentsFactoryService = loader.CommandLineArgumentsFactoryService;
}
internal static ProjectInstance LoadProjectInstance(MSBuild.Evaluation.ProjectCollection projectCollection, ProjectRootElement rootElement, IDictionary<string, string> globalProps)
{
lock (SolutionProjectCollectionLock) {
string toolsVersion = rootElement.ToolsVersion;
if (string.IsNullOrEmpty(toolsVersion))
toolsVersion = projectCollection.DefaultToolsVersion;
return new ProjectInstance(rootElement, globalProps, toolsVersion, projectCollection);
}
}
private void InitializeFromModel(CSharpCompilerInputs compilerInputs, MSB.Execution.ProjectInstance executedProject)
{
compilerInputs.BeginInitialization();
compilerInputs.SetAllowUnsafeBlocks(this.ReadPropertyBool(executedProject, "AllowUnsafeBlocks"));
compilerInputs.SetApplicationConfiguration(this.ReadPropertyString(executedProject, "AppConfigForCompiler"));
compilerInputs.SetBaseAddress(this.ReadPropertyString(executedProject, "BaseAddress"));
compilerInputs.SetCheckForOverflowUnderflow(this.ReadPropertyBool(executedProject, "CheckForOverflowUnderflow"));
compilerInputs.SetCodePage(this.ReadPropertyInt(executedProject, "CodePage"));
compilerInputs.SetDebugType(this.ReadPropertyString(executedProject, "DebugType"));
compilerInputs.SetDefineConstants(this.ReadPropertyString(executedProject, "DefineConstants"));
var delaySignProperty = this.GetProperty("DelaySign");
compilerInputs.SetDelaySign(delaySignProperty != null && !string.IsNullOrEmpty(delaySignProperty.EvaluatedValue), this.ReadPropertyBool(executedProject, "DelaySign"));
compilerInputs.SetDisabledWarnings(this.ReadPropertyString(executedProject, "NoWarn"));
compilerInputs.SetDocumentationFile(this.GetItemString(executedProject, "DocFileItem"));
compilerInputs.SetEmitDebugInformation(this.ReadPropertyBool(executedProject, "DebugSymbols"));
compilerInputs.SetErrorReport(this.ReadPropertyString(executedProject, "ErrorReport"));
compilerInputs.SetFileAlignment(this.ReadPropertyInt(executedProject, "FileAlignment"));
compilerInputs.SetGenerateFullPaths(this.ReadPropertyBool(executedProject, "GenerateFullPaths"));
compilerInputs.SetHighEntropyVA(this.ReadPropertyBool(executedProject, "HighEntropyVA"));
bool signAssembly = this.ReadPropertyBool(executedProject, "SignAssembly");
if (signAssembly)
{
compilerInputs.SetKeyContainer(this.ReadPropertyString(executedProject, "KeyContainerName"));
compilerInputs.SetKeyFile(this.ReadPropertyString(executedProject, "KeyOriginatorFile", "AssemblyOriginatorKeyFile"));
}
compilerInputs.SetLangVersion(this.ReadPropertyString(executedProject, "LangVersion"));
compilerInputs.SetMainEntryPoint(null, this.ReadPropertyString(executedProject, "StartupObject"));
compilerInputs.SetModuleAssemblyName(this.ReadPropertyString(executedProject, "ModuleAssemblyName"));
compilerInputs.SetNoStandardLib(this.ReadPropertyBool(executedProject, "NoCompilerStandardLib"));
compilerInputs.SetOptimize(this.ReadPropertyBool(executedProject, "Optimize"));
compilerInputs.SetOutputAssembly(this.GetItemString(executedProject, "IntermediateAssembly"));
compilerInputs.SetPdbFile(this.ReadPropertyString(executedProject, "PdbFile"));
if (this.ReadPropertyBool(executedProject, "Prefer32Bit"))
{
compilerInputs.SetPlatformWith32BitPreference(this.ReadPropertyString(executedProject, "PlatformTarget"));
}
else
{
compilerInputs.SetPlatform(this.ReadPropertyString(executedProject, "PlatformTarget"));
}
compilerInputs.SetSubsystemVersion(this.ReadPropertyString(executedProject, "SubsystemVersion"));
compilerInputs.SetTargetType(this.ReadPropertyString(executedProject, "OutputType"));
// Decode the warning options from RuleSet file prior to reading explicit settings in the project file, so that project file settings prevail for duplicates.
compilerInputs.SetRuleSet(this.ReadPropertyString(executedProject, "RuleSet"));
compilerInputs.SetTreatWarningsAsErrors(this.ReadPropertyBool(executedProject, "TreatWarningsAsErrors"));
compilerInputs.SetWarningLevel(this.ReadPropertyInt(executedProject, "WarningLevel"));
compilerInputs.SetWarningsAsErrors(this.ReadPropertyString(executedProject, "WarningsAsErrors"));
compilerInputs.SetWarningsNotAsErrors(this.ReadPropertyString(executedProject, "WarningsNotAsErrors"));
compilerInputs.SetReferences(this.GetMetadataReferencesFromModel(executedProject).ToArray());
compilerInputs.SetAnalyzers(this.GetAnalyzerReferencesFromModel(executedProject).ToArray());
compilerInputs.SetSources(this.GetDocumentsFromModel(executedProject).ToArray());
string errorMessage;
int errorCode;
compilerInputs.EndInitialization(out errorMessage, out errorCode);
}
private ImmutableArray<string> GetAliases(MSB.Framework.ITaskItem item)
{
var aliasesText = item.GetMetadata("Aliases");
if (string.IsNullOrEmpty(aliasesText))
{
return ImmutableArray<string>.Empty;
}
return ImmutableArray.CreateRange(aliasesText.Split(new char[] { ' ', ',' }, StringSplitOptions.RemoveEmptyEntries));
}
public LoadedProjectInfo(MSB.Evaluation.Project project, string errorMessage)
{
this.Project = project;
this.ErrorMessage = errorMessage;
}
internal static PropertyStorageLocations GetLocationFromCondition(MSBuild.Construction.ProjectElement element)
{
while (element != null) {
if (!string.IsNullOrEmpty(element.Condition))
return GetLocationFromCondition(element.Condition);
element = element.Parent;
}
return PropertyStorageLocations.Base;
}
public bool SetResponseFiles(MSB.Framework.ITaskItem[] responseFiles)
{
// ??
return true;
}
public BuildTargets(MSB.Evaluation.Project project, params string[] targets)
{
this.project = project;
this.buildTargets = new List<string>();
this.buildTargets.AddRange(targets);
}
public bool SetAnalyzers(MSB.Framework.ITaskItem[] analyzerReferences)
{
this.AnalyzerReferences = analyzerReferences ?? SpecializedCollections.EmptyEnumerable<MSB.Framework.ITaskItem>();
return true;
}
private static IEnumerable<string> GetTargetDependents(MSB.Evaluation.Project project, string targetName)
{
MSB.Execution.ProjectTargetInstance targetInstance;
if (project.Targets.TryGetValue(targetName, out targetInstance))
{
return SplitTargets(project.ExpandString(targetInstance.DependsOnTargets));
}
else
{
return SpecializedCollections.EmptyEnumerable<string>();
}
}
internal static IEnumerable<string> GetTopLevelTargets(MSB.Evaluation.Project project)
{
// start with set of all targets
HashSet<string> targets = new HashSet<string>(project.Targets.Keys);
// remove any target that another target depends on
foreach (var target in project.Targets.Keys)
{
var dependents = GetTargetDependents(project, target).ToList();
foreach (var depTarget in dependents)
{
targets.Remove(depTarget);
}
}
return targets;
}
public VisualBasicProjectFile(VisualBasicProjectFileLoader loader, MSB.Evaluation.Project loadedProject) : base(loader, loadedProject)
{
}
protected override ProjectFile CreateProjectFile(MSB.Evaluation.Project loadedProject)
{
return new VisualBasicProjectFile(this, loadedProject);
}
protected override ProjectFile CreateProjectFile(MSB.Evaluation.Project loadedProject)
{
return new CSharpProjectFile(this, loadedProject, _workspaceServices.GetService<IMetadataService>(), _workspaceServices.GetService<IAnalyzerService>());
}
public CSharpProjectFile(CSharpProjectFileLoader loader, MSB.Evaluation.Project project)
: base(loader, project)
{
}
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);
var resolver = new MetadataFileReferenceResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory);
metadataReferences = commandLineArgs.ResolveMetadataReferences(new AssemblyReferenceResolver(resolver, _metadataService.GetProvider()));
analyzerReferences = commandLineArgs.ResolveAnalyzerReferences();
}
public bool SetReferences(MSB.Framework.ITaskItem[] references)
{
this.References = references ?? SpecializedCollections.EmptyEnumerable<MSB.Framework.ITaskItem>();
return true;
}
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)
{
if (!IsProjectReferenceOutputAssembly(mr))
{
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 commandLineArgs = _commandLineArgumentsFactoryService.CreateCommandLineArguments(args, executedProject.Directory, isInteractive: false, sdkDirectory: 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);
}
public bool SetResources(MSB.Framework.ITaskItem[] resources)
{
// ??
return true;
}
protected abstract ProjectFile CreateProjectFile(MSB.Evaluation.Project loadedProject);
public bool SetSources(MSB.Framework.ITaskItem[] sources)
{
this.Sources = sources ?? SpecializedCollections.EmptyEnumerable<MSB.Framework.ITaskItem>();
return true;
}
private DocumentFileInfo MakeDocumentFileInfo(string projectDirectory, MSB.Framework.ITaskItem item)
{
var filePath = GetDocumentFilePath(item);
var logicalPath = GetDocumentLogicalPath(item, projectDirectory);
var isLinked = IsDocumentLinked(item);
var isGenerated = IsDocumentGenerated(item);
return new DocumentFileInfo(filePath, logicalPath, isLinked, isGenerated);
}
protected override ProjectFile CreateProjectFile(MSB.Evaluation.Project loadedProject)
{
return new CSharpProjectFile(this, loadedProject);
}
private IEnumerable<MetadataInfo> MakeMetadataInfo(MSB.Framework.ITaskItem item)
{
var filePath = GetDocumentFilePath(item);
var aliases = GetAliases(item);
return new MetadataInfo[] { new MetadataInfo(filePath, new MetadataReferenceProperties(aliases: aliases)) };
}
internal static void UnloadProject(MSBuild.Evaluation.ProjectCollection projectCollection, MSBuild.Evaluation.Project project)
{
lock (SolutionProjectCollectionLock) {
projectCollection.UnloadProject(project);
}
}
public CSharpProjectFile(CSharpProjectFileLoader loader, MSB.Evaluation.Project project, IMetadataService metadataService)
: base(loader, project)
{
_metadataService = metadataService;
}
