private void ProcessOptions(IProjectRuleSnapshot snapshot) { // We just pass all options to Roslyn string commandlineArguments = string.Join(" ", snapshot.Items.Keys); _context.SetOptions(commandlineArguments); }
private static EnumCollection Transform(IProjectSubscriptionUpdate input) { IProjectRuleSnapshot snapshot = input.CurrentState[SupportedTargetFrameworkAlias.SchemaName]; return(snapshot.Items.Select(ToEnumValue) .ToList()); }
public TestProjectChangeDescription(IProjectRuleSnapshot before, IProjectRuleSnapshot after) { Before = before; After = after; Difference = Diff.Create(before, after); }
private string GetUnresolvedReferenceItemType( string unresolvedItemSpec, IEnumerable <IProjectRuleSnapshot> unresolvedReferenceSnapshots, IProjectCatalogSnapshot catalogs, out IProjectRuleSnapshot unresolvedReferenceSnapshot) { Requires.NotNull(unresolvedItemSpec, nameof(unresolvedItemSpec)); Requires.NotNull(unresolvedReferenceSnapshots, nameof(unresolvedReferenceSnapshots)); Requires.NotNull(catalogs, nameof(catalogs)); unresolvedReferenceSnapshot = null; foreach (var referenceSnapshot in unresolvedReferenceSnapshots) { if (referenceSnapshot.Items.ContainsKey(unresolvedItemSpec)) { var itemType = GetItemTypeFromRuleName(referenceSnapshot.RuleName, catalogs, true); if (itemType != null) { unresolvedReferenceSnapshot = referenceSnapshot; return(itemType); } } } return(null); }
private void ProcessOptions(IProjectRuleSnapshot snapshot) { Assumes.NotNull(_context); // We just pass all options to Roslyn _context.SetOptions(snapshot.Items.Keys.ToImmutableArray()); }
private ISet <WorkloadDescriptor> CreateWorkloadDescriptor(IImmutableDictionary <string, IProjectRuleSnapshot> currentState) { IProjectRuleSnapshot suggestedWorkloads = currentState.GetSnapshotOrEmpty(SuggestedWorkload.SchemaName); if (suggestedWorkloads.Items.Count == 0) { return(ImmutableHashSet <WorkloadDescriptor> .Empty); } var workloadDescriptors = suggestedWorkloads.Items.Select(item => { string workloadName = item.Key; if (!string.IsNullOrWhiteSpace(workloadName) && (item.Value.TryGetStringProperty(SuggestedWorkload.VisualStudioComponentIdsProperty, out string?vsComponentIds) || item.Value.TryGetStringProperty(SuggestedWorkload.VisualStudioComponentIdProperty, out vsComponentIds))) { return(new WorkloadDescriptor(workloadName, vsComponentIds)); } return(WorkloadDescriptor.Empty); }); return(new HashSet <WorkloadDescriptor>(workloadDescriptors)); }
public static IProjectChangeDescription Implement(IProjectRuleSnapshot after = null, IProjectRuleSnapshot before = null, IProjectChangeDiff difference = null, MockBehavior?mockBehavior = null) { var behavior = mockBehavior ?? MockBehavior.Default; var mock = new Mock <IProjectChangeDescription>(behavior); if (after != null) { mock.Setup(x => x.After).Returns(after); } if (before != null) { mock.Setup(x => x.Before).Returns(before); } if (difference != null) { mock.Setup(x => x.Difference).Returns(difference); } return(mock.Object); }
/// <summary> /// Converts an immutable dictionary of rule snapshot data into an <see cref="IVsProjectRestoreInfo"/> instance. /// </summary> public static ProjectRestoreInfo ToProjectRestoreInfo(IImmutableDictionary <string, IProjectRuleSnapshot> update) { IImmutableDictionary <string, string> properties = update.GetSnapshotOrEmpty(NuGetRestore.SchemaName).Properties; IProjectRuleSnapshot frameworkReferences = update.GetSnapshotOrEmpty(CollectedFrameworkReference.SchemaName); IProjectRuleSnapshot packageDownloads = update.GetSnapshotOrEmpty(CollectedPackageDownload.SchemaName); IProjectRuleSnapshot projectReferences = update.GetSnapshotOrEmpty(ProjectReference.SchemaName); IProjectRuleSnapshot packageReferences = update.GetSnapshotOrEmpty(PackageReference.SchemaName); IProjectRuleSnapshot toolReferences = update.GetSnapshotOrEmpty(DotNetCliToolReference.SchemaName); // For certain project types such as UWP, "TargetFrameworkMoniker" != the moniker that restore uses string targetMoniker = properties.GetPropertyOrEmpty(NuGetRestore.NuGetTargetMonikerProperty); if (targetMoniker.Length == 0) { targetMoniker = properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworkMonikerProperty); } IVsTargetFrameworkInfo2 frameworkInfo = new TargetFrameworkInfo( targetMoniker, ToReferenceItems(frameworkReferences.Items), ToReferenceItems(packageDownloads.Items), ToReferenceItems(projectReferences.Items), ToReferenceItems(packageReferences.Items), ToProjectProperties(properties)); return(new ProjectRestoreInfo( properties.GetPropertyOrEmpty(NuGetRestore.MSBuildProjectExtensionsPathProperty), properties.GetPropertyOrEmpty(NuGetRestore.ProjectAssetsFileProperty), properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworksProperty), new TargetFrameworks(new[] { frameworkInfo }), ToReferenceItems(toolReferences.Items))); }
private IDependencyModel CreateDependencyModelForRule( string itemSpec, bool resolved, IProjectRuleSnapshot projectRuleSnapshot, ITargetFramework targetFramework) { var properties = GetProjectItemProperties(projectRuleSnapshot, itemSpec); var originalItemSpec = itemSpec; if (resolved) { originalItemSpec = GetOriginalItemSpec(properties); } var isImplicit = false; if (properties != null && properties.TryGetValue(ProjectItemMetadata.IsImplicitlyDefined, out string isImplicitlyDefinedString) && bool.TryParse(isImplicitlyDefinedString, out bool isImplicitlyDefined)) { isImplicit = isImplicitlyDefined; } return(CreateDependencyModel( ProviderType, itemSpec, originalItemSpec, resolved, isImplicit, properties)); }
/// <summary> /// Converts an immutable dictionary of rule snapshot data into an <see cref="IVsProjectRestoreInfo"/> instance. /// </summary> public static IVsProjectRestoreInfo2 ToProjectRestoreInfo(IImmutableDictionary <string, IProjectRuleSnapshot> update) { Requires.NotNull(update, nameof(update)); IImmutableDictionary <string, string> properties = update.GetSnapshotOrEmpty(NuGetRestore.SchemaName).Properties; IProjectRuleSnapshot frameworkReferences = update.GetSnapshotOrEmpty(CollectedFrameworkReference.SchemaName); IProjectRuleSnapshot packageDownloads = update.GetSnapshotOrEmpty(CollectedPackageDownload.SchemaName); IProjectRuleSnapshot projectReferences = update.GetSnapshotOrEmpty(ProjectReference.SchemaName); IProjectRuleSnapshot packageReferences = update.GetSnapshotOrEmpty(PackageReference.SchemaName); IProjectRuleSnapshot toolReferences = update.GetSnapshotOrEmpty(DotNetCliToolReference.SchemaName); IVsTargetFrameworkInfo2 frameworkInfo = new TargetFrameworkInfo( properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworkMonikerProperty), ToReferenceItems(frameworkReferences.Items), ToReferenceItems(packageDownloads.Items), ToReferenceItems(projectReferences.Items), ToReferenceItems(packageReferences.Items), ToProjectProperties(properties)); return(new ProjectRestoreInfo( properties.GetPropertyOrEmpty(NuGetRestore.MSBuildProjectExtensionsPathProperty), properties.GetPropertyOrEmpty(NuGetRestore.TargetFrameworksProperty), new TargetFrameworks(new[] { frameworkInfo }), ToReferenceItems(toolReferences.Items))); }
private IDependencyModel?CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot evaluationRuleSnapshot, IProjectRuleSnapshot updatedRuleSnapshot, bool isResolved, string projectFullPath) { IImmutableDictionary <string, string>?properties = updatedRuleSnapshot.GetProjectItemProperties(itemSpec); Assumes.NotNull(properties); string originalItemSpec = isResolved ? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec : itemSpec; IImmutableDictionary <string, string>?evaluationProperties = evaluationRuleSnapshot.GetProjectItemProperties(originalItemSpec); if (evaluationProperties == null) { if (ResolvedItemRequiresEvaluatedItem) { // This item is present in build results, but not in evaluation. return(null); } evaluationProperties = properties; } bool isImplicit = IsImplicit(projectFullPath, evaluationProperties); return(CreateDependencyModel( itemSpec, originalItemSpec, isResolved, isImplicit, properties)); }
private void ProcessProjectBuildFailure(IProjectRuleSnapshot snapshot) { // If 'CompileDesignTime' didn't run due to a preceding failed target, or a failure in itself, IsEvaluationSucceeded returns false. // // We still forward those 'removes' of references, sources, etc onto Roslyn to avoid duplicate/incorrect results when the next // successful build occurs, because it will be diff between it and this failed build. _context.LastDesignTimeBuildSucceeded = snapshot.IsEvaluationSucceeded(); }
private async Task <ProjectContextInitData> GetProjectContextInitDataAsync(ConfiguredProject project) { Guid projectGuid = await _projectGuidService.GetProjectGuidAsync(); IProjectRuleSnapshot snapshot = await GetLatestSnapshotAsync(project); return(ProjectContextInitData.GetProjectContextInitData(snapshot, projectGuid, project.ProjectConfiguration)); }
/// <summary> /// Finds the resolved reference item for a given unresolved reference. /// </summary> /// <param name="projectRuleSnapshot">Resolved reference project items snapshot to search.</param> /// <param name="itemSpec">The unresolved reference item name.</param> /// <returns>The key is item name and the value is the metadata dictionary.</returns> public static IImmutableDictionary <string, string> GetProjectItemProperties(this IProjectRuleSnapshot projectRuleSnapshot, string itemSpec) { Requires.NotNull(projectRuleSnapshot, nameof(projectRuleSnapshot)); Requires.NotNullOrEmpty(itemSpec, nameof(itemSpec)); return(projectRuleSnapshot.Items.TryGetValue(itemSpec, out IImmutableDictionary <string, string> properties) ? properties : null); }
public static Diff Create(IProjectRuleSnapshot before, IProjectRuleSnapshot after) { var addedItems = new HashSet <string>(after.Items.Keys); addedItems.ExceptWith(before.Items.Keys); var removedItems = new HashSet <string>(before.Items.Keys); removedItems.ExceptWith(after.Items.Keys); // changed items must be present in both sets, but have different properties. var changedItems = new HashSet <string>(before.Items.Keys); changedItems.IntersectWith(after.Items.Keys); changedItems.RemoveWhere(key => { var x = before.Items[key]; var y = after.Items[key]; if (x.Count != y.Count) { return(true); } foreach (var kvp in x) { if (!y.Contains(kvp)) { return(true); } } return(false); }); var changedProperties = new HashSet <string>(before.Properties.Keys); changedProperties.RemoveWhere(key => { var x = before.Properties[key]; var y = after.Properties[key]; return(object.Equals(x, y)); }); return(new Diff() { AddedItems = addedItems.ToImmutableHashSet(), RemovedItems = removedItems.ToImmutableHashSet(), ChangedItems = changedItems.ToImmutableHashSet(), // We ignore renamed items. RenamedItems = ImmutableDictionary <string, string> .Empty, ChangedProperties = changedProperties.ToImmutableHashSet(), }); }
public static IProjectRuleSnapshot Add(this IProjectRuleSnapshot snapshot, string propertyName, string propertyValue) { var mock = Mock.Get(snapshot); var dictionary = snapshot.Properties.Add(propertyName, propertyValue); mock.SetupGet(r => r.Properties) .Returns(dictionary); return(mock.Object); }
public static ProjectContextInitData GetProjectContextInitData(IProjectRuleSnapshot snapshot, Guid projectGuid, ProjectConfiguration configuration) { var data = new ProjectContextInitData(); snapshot.Properties.TryGetValue(ConfigurationGeneral.LanguageServiceNameProperty, out data.LanguageName); snapshot.Properties.TryGetValue(ConfigurationGeneral.TargetPathProperty, out data.BinOutputPath); snapshot.Properties.TryGetValue(ConfigurationGeneral.MSBuildProjectFullPathProperty, out data.ProjectFilePath); data.ProjectGuid = projectGuid; data.WorkspaceProjectContextId = GetWorkspaceProjectContextId(data.ProjectFilePath, projectGuid, configuration); return(data); }
private FileWatchData CreateFileWatch(IImmutableDictionary <string, IProjectRuleSnapshot> update) { IProjectRuleSnapshot snapshot = update.GetSnapshotOrEmpty(ItemSchemaName); var fullPaths = snapshot.Items.Select(item => item.Value.GetValueOrDefault(Compile.FullPathProperty)) .Where(item => item != null) .ToImmutableList(); return(new FileWatchData( this, fullPaths, FileWatchChangeKinds)); }
protected override EnumCollection Transform(IProjectSubscriptionUpdate input) { IProjectRuleSnapshot?configurationGeneral = input.CurrentState[ConfigurationGeneral.SchemaName]; string?targetFrameworkIdentifier = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkIdentifierProperty]; string ruleName; if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetCoreApp)) { ruleName = SupportedNETCoreAppTargetFramework.SchemaName; } else if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetFramework)) { ruleName = SupportedNETFrameworkTargetFramework.SchemaName; } else if (StringComparers.FrameworkIdentifiers.Equals(targetFrameworkIdentifier, TargetFrameworkIdentifiers.NetStandard)) { ruleName = SupportedNETStandardTargetFramework.SchemaName; } else { string?storedTargetFramework = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkProperty]; string?storedTargetFrameworkIdentifier = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkIdentifierProperty]; string?storedTargetFrameworkMoniker = configurationGeneral.Properties[ConfigurationGeneral.TargetFrameworkMonikerProperty]; var result = new List <IEnumValue>(); // This is the case where the TargetFrameworkProperty has a value we recognize but it's not in the supported lists the SDK sends us. // We decided we will show it in the UI. if (!Strings.IsNullOrEmpty(storedTargetFramework)) { result.Add(new PageEnumValue(new EnumValue { Name = (!Strings.IsNullOrEmpty(storedTargetFrameworkMoniker))? storedTargetFrameworkMoniker : storedTargetFramework, DisplayName = (!Strings.IsNullOrEmpty(storedTargetFrameworkIdentifier)) ? storedTargetFrameworkIdentifier : storedTargetFramework })); } return(result); } IProjectRuleSnapshot snapshot = input.CurrentState[ruleName]; int capacity = snapshot.Items.Count; var list = new List <IEnumValue>(capacity); list.AddRange(snapshot.Items.Select(ToEnumValue)); list.Sort(SortValues); // TODO: This is a hotfix for item ordering. Remove this when completing: https://github.com/dotnet/project-system/issues/7025 return(list); }
private void ProcessProjectBuildFailure(IProjectRuleSnapshot snapshot) { // If 'CompileDesignTime' didn't run due to a preceding failed target, or a failure in itself, IsEvaluationSucceeded returns false. // // We still forward those 'removes' of references, sources, etc onto Roslyn to avoid duplicate/incorrect results when the next // successful build occurs, because it will be diff between it and this failed build. bool succeeded = snapshot.IsEvaluationSucceeded(); if (_context.LastDesignTimeBuildSucceeded != succeeded) { _logger.WriteLine(succeeded ? "Last design-time build succeeded, turning semantic errors back on." : "Last design-time build failed, turning semantic errors off."); _context.LastDesignTimeBuildSucceeded = succeeded; } }
private IDependencyModel CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot projectRuleSnapshot, bool isResolved) { IImmutableDictionary <string, string> properties = projectRuleSnapshot.GetProjectItemProperties(itemSpec) !; string originalItemSpec = isResolved ? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec : itemSpec; bool isImplicit = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false; return(CreateDependencyModel( itemSpec, originalItemSpec, isResolved, isImplicit, properties)); }
private static string ResolveFallbackIntermediateOutputPath(IProjectRuleSnapshot rule, string intermediateOutputPathValue) { if (!rule.Properties.TryGetValue(MSBuildProjectDirectoryPropertyName, out var projectDirectory)) { // Can't resolve the project, bail. return(null); } var joinedPath = Path.Combine(projectDirectory, intermediateOutputPathValue); if (!Directory.Exists(joinedPath)) { return(null); } return(joinedPath); }
protected virtual void HandleAddedItem( string projectFullPath, string addedItem, bool resolved, IProjectChangeDescription projectChange, IProjectRuleSnapshot evaluationRuleSnapshot, DependenciesChangesBuilder changesBuilder, TargetFramework targetFramework, Func <string, bool>?isEvaluatedItemSpec) { IDependencyModel?model = CreateDependencyModelForRule(addedItem, evaluationRuleSnapshot, projectChange.After, resolved, projectFullPath); if (model != null && (isEvaluatedItemSpec == null || isEvaluatedItemSpec(model.Id))) { changesBuilder.Added(model); } }
/// <summary> /// Finds the resolved reference item for a given unresolved reference. /// </summary> /// <param name="projectRuleSnapshot">Resolved reference project items snapshot to search.</param> /// <param name="unresolvedItemSpec">The unresolved reference item name.</param> /// <returns>The key is item name and the value is the metadata dictionary.</returns> protected static IImmutableDictionary <string, string> GetProjectItemProperties( IProjectRuleSnapshot projectRuleSnapshot, string unresolvedItemSpec) { Contract.Requires(projectRuleSnapshot != null); Contract.Requires(!string.IsNullOrEmpty(unresolvedItemSpec)); foreach (var item in projectRuleSnapshot.Items) { string originalItemSpec = item.Key; if (string.Equals(originalItemSpec, unresolvedItemSpec, StringComparison.OrdinalIgnoreCase)) { return(item.Value); } } return(null); }
protected virtual void HandleRemovedItem( string projectFullPath, string removedItem, bool resolved, IProjectChangeDescription projectChange, IProjectRuleSnapshot evaluationRuleSnapshot, DependenciesChangesBuilder changesBuilder, TargetFramework targetFramework, Func <string, bool>?isEvaluatedItemSpec) { string dependencyId = resolved ? projectChange.Before.GetProjectItemProperties(removedItem) !.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? removedItem : removedItem; if (isEvaluatedItemSpec == null || isEvaluatedItemSpec(dependencyId)) { changesBuilder.Removed(ProviderType, removedItem); } }
private IDependencyModel?CreateDependencyModelForRule( string itemSpec, IProjectRuleSnapshot evaluationRuleSnapshot, IProjectRuleSnapshot updatedRuleSnapshot, bool isResolved, DependenciesChangesBuilder changesBuilder, TargetFramework targetFramework, string projectFullPath) { IImmutableDictionary <string, string>?properties = updatedRuleSnapshot.GetProjectItemProperties(itemSpec); Assumes.NotNull(properties); string originalItemSpec = isResolved ? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec : itemSpec; IImmutableDictionary <string, string>?evaluationProperties = evaluationRuleSnapshot.GetProjectItemProperties(originalItemSpec); if (evaluationProperties == null) { if (ResolvedItemRequiresEvaluatedItem) { // This item is present in build results, but not in evaluation. return(null); } evaluationProperties = properties; } bool isImplicit = IsImplicit(projectFullPath, evaluationProperties); // When we only have evaluation data, mark the dependency as resolved if we currently have a corresponding resolved item isResolved = isResolved || changesBuilder.HasResolvedItem(targetFramework, ProviderType, originalItemSpec); return(CreateDependencyModel( itemSpec, originalItemSpec, isResolved, isImplicit, properties)); }
private IDependencyModel CreateDependencyModelForRule(string itemSpec, IProjectRuleSnapshot projectRuleSnapshot, bool isResolved) { IImmutableDictionary <string, string> properties = projectRuleSnapshot.GetProjectItemProperties(itemSpec) !; string originalItemSpec = isResolved ? properties.GetStringProperty(ProjectItemMetadata.OriginalItemSpec) ?? itemSpec : itemSpec; // NOTE the SDK only sets this for a default set of implicit dependencies. At this point, this data // does not reflect implicit dependencies brought in by imported project files. That behaviour is // added by ImplicitDependenciesSnapshotFilter. bool isImplicit = properties.GetBoolProperty(ProjectItemMetadata.IsImplicitlyDefined) ?? false; return(CreateDependencyModel( itemSpec, originalItemSpec, isResolved, isImplicit, properties)); }
protected override EnumCollection Transform(IProjectSubscriptionUpdate input) { IProjectRuleSnapshot snapshot = input.CurrentState[_ruleName]; int capacity = snapshot.Items.Count + (_useNoneValue ? 1 : 0); var list = new List <IEnumValue>(capacity); if (_useNoneValue) { list.Add(new PageEnumValue(new EnumValue { Name = string.Empty, DisplayName = Resources.Property_NoneValue })); } list.AddRange(snapshot.Items.Select(ToEnumValue)); list.Sort(SortValues); // TODO: This is a hotfix for item ordering. Remove this when completing: https://github.com/dotnet/project-system/issues/7025 return(list); }
protected virtual void HandleChangedItem( string projectFullPath, string changedItem, bool resolved, IProjectChangeDescription projectChange, IProjectRuleSnapshot evaluationRuleSnapshot, DependenciesChangesBuilder changesBuilder, TargetFramework targetFramework, Func <string, bool>?isEvaluatedItemSpec) { IDependencyModel?model = CreateDependencyModelForRule(changedItem, evaluationRuleSnapshot, projectChange.After, resolved, projectFullPath); if (model != null && (isEvaluatedItemSpec == null || isEvaluatedItemSpec(model.Id))) { // For changes we try to add new dependency. If it is a resolved dependency, it would just override // old one with new properties. If it is unresolved dependency, it would be added only when there is // no resolved version in the snapshot (due to UnresolvedDependenciesSnapshotFilter). changesBuilder.Added(model); } }
private HostDocument[] GetCurrentDocuments(IProjectSubscriptionUpdate update) { IProjectRuleSnapshot rule = null; var documents = new List <HostDocument>(); if (update.CurrentState.TryGetValue(Rules.RazorComponentWithTargetPath.SchemaName, out rule)) { foreach (var kvp in rule.Items) { if (kvp.Value.TryGetValue(Rules.RazorComponentWithTargetPath.TargetPathProperty, out var targetPath) && !string.IsNullOrWhiteSpace(kvp.Key) && !string.IsNullOrWhiteSpace(targetPath)) { var filePath = CommonServices.UnconfiguredProject.MakeRooted(kvp.Key); var fileKind = FileKinds.GetComponentFileKindFromFilePath(filePath); documents.Add(new HostDocument(filePath, targetPath, fileKind)); } } } if (update.CurrentState.TryGetValue(Rules.RazorGenerateWithTargetPath.SchemaName, out rule)) { foreach (var kvp in rule.Items) { if (kvp.Value.TryGetValue(Rules.RazorGenerateWithTargetPath.TargetPathProperty, out var targetPath) && !string.IsNullOrWhiteSpace(kvp.Key) && !string.IsNullOrWhiteSpace(targetPath)) { var filePath = CommonServices.UnconfiguredProject.MakeRooted(kvp.Key); documents.Add(new HostDocument(filePath, targetPath, FileKinds.Legacy)); } } } return(documents.ToArray()); }