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; }