/// <summary>
/// Returns an option set with all the serializable option values prefetched for given <paramref name="languages"/>,
/// while also retaining all the explicitly changed option values in this option set for any language.
/// Note: All the provided <paramref name="languages"/> must be <see cref="RemoteSupportedLanguages.IsSupported(string)"/>.
/// </summary>
public SerializableOptionSet UnionWithLanguages(ImmutableHashSet <string> languages)
{
Debug.Assert(languages.All(RemoteSupportedLanguages.IsSupported));
if (_languages.Value.IsSupersetOf(languages))
{
return(this);
}
// First create a base option set for the given languages.
languages = languages.Union(_languages.Value);
var newOptionSet = _workspaceOptionSet.OptionService.GetSerializableOptionsSnapshot(languages);
// Then apply all the changed options from the current option set to the new option set.
foreach (var changedOption in this.GetChangedOptions())
{
var valueInNewOptionSet = newOptionSet.GetOption(changedOption);
var changedValueInThisOptionSet = this.GetOption(changedOption);
if (!Equals(changedValueInThisOptionSet, valueInNewOptionSet))
{
newOptionSet = (SerializableOptionSet)newOptionSet.WithChangedOption(changedOption, changedValueInThisOptionSet);
}
}
return(newOptionSet);
}
public async Task <bool> Link(IImmutableSet <string> userIds)
{
List <LinkedAccount> linkedAccountEntries = await _collection
// .Find(l => l.UserIds.Intersect(userIds).Any())
.Find(Builders <LinkedAccount> .Filter.AnyIn(l => l.UserIds, userIds))
.ToListAsync();
ImmutableHashSet <string> existingUserIds = linkedAccountEntries
.SelectMany(l => l.UserIds)
.ToImmutableHashSet();
ImmutableHashSet <string> allUserIds = existingUserIds.Union(userIds);
if (existingUserIds.Count == allUserIds.Count)
{
return(false); // already marked as linked
}
// don't bother patching existing documents, just delete all old ones and make a new one
await _collection.InsertOneAsync(new LinkedAccount(string.Empty, allUserIds.ToHashSet()));
foreach ((string id, _) in linkedAccountEntries)
{
await _collection.DeleteOneAsync(l => l.Id == id);
}
return(true);
}
internal static void AddRouteAllowList(IEnumerable <string> list)
{
if (list != null)
{
Allowlist = Allowlist.Union(list);
}
}
private ImmutableHashSet <CounterElement> MergeElements(ImmutableHashSet <CounterElement> firstSet, ImmutableHashSet <CounterElement> secondSet)
{
var union = firstSet.Union(secondSet);
var filteredElements = union.Where(u => !union.Any(e => Equals(u.Node, e.Node) && u.Value < e.Value));
return(filteredElements.ToImmutableHashSet());
}
public Task <ImmutableHashSet <TChromosome> > SelectAsync(
ImmutableHashSet <TChromosome> eliteOffspring,
ImmutableHashSet <TChromosome> lastFront,
int expectedOffspringCount,
CancellationToken token)
{
var joined = lastFront.Union(eliteOffspring);
var remainingCount = expectedOffspringCount - eliteOffspring.Count;
var measurable = SelectMeasurableOffspring(eliteOffspring, lastFront)
.ToDictionary(chromosome => chromosome, _ => 0d);
foreach (var objective in _objectives)
{
var ordered = joined.OrderBy(chromosome =>
_mapper.GetValue(objective, chromosome.Fitness))
.ThenBy(chromosome =>
_objectives.Average(obj =>
_mapper.GetValue(obj, chromosome.Fitness)))
.ToImmutableArray();
var first = ordered.First();
var last = ordered.Last();
if (measurable.ContainsKey(first) || measurable.ContainsKey(last))
{
var longestDistance = CalculateDistance(first, last);
if (measurable.ContainsKey(first))
{
measurable[first] += longestDistance;
}
if (measurable.ContainsKey(last))
{
measurable[last] += longestDistance;
}
}
for (var i = 1; i < ordered.Length - 1; i++)
{
if (!measurable.ContainsKey(ordered[i]))
{
continue;
}
var lower = ordered[i - 1];
var higher = ordered[i + 1];
var distance = CalculateDistance(lower, higher);
measurable[ordered[i]] += distance;
}
}
var selected = FilterMeasuredOffspring(
eliteOffspring,
measurable,
expectedOffspringCount,
remainingCount);
return(Task.FromResult(selected));
}
public void ImmutableSetAdapter_Ctor_Succeeds()
{
const int NumberOfMethods = 17;
int[] methodsCalled = new int[NumberOfMethods];
ImmutableHashSet <int> realSet = ImmutableHashSet <int> .Empty;
System.Collections.Immutable.IImmutableSet <int> backingSet =
new MockSystemImmutableSet <int>(
addDelegate: x => { methodsCalled[0]++; return(realSet.Add(x)); },
clearDelegate: () => { methodsCalled[1]++; return(realSet.Clear()); },
containsDelegate: x => { methodsCalled[2]++; return(realSet.Contains(x)); },
countDelegate: () => { methodsCalled[3]++; return(realSet.Count); },
equalsDelegate: null,
exceptDelegate: x => { methodsCalled[4]++; return(realSet.Except(x)); },
getEnumeratorDelegate: () => { methodsCalled[5]++; return(realSet.GetEnumerator()); },
getHashCodeDelegate: null,
intersectDelegate: x => { methodsCalled[6]++; return(realSet.Intersect(x)); },
isProperSubsetOfDelegate: x => { methodsCalled[7]++; return(realSet.IsProperSubsetOf(x)); },
isProperSupersetOfDelegate: x => { methodsCalled[8]++; return(realSet.IsProperSupersetOf(x)); },
isSubsetOfDelegate: x => { methodsCalled[9]++; return(realSet.IsSubsetOf(x)); },
isSupersetOfDelegate: x => { methodsCalled[10]++; return(realSet.IsSupersetOf(x)); },
overlapsDelegate: x => { methodsCalled[11]++; return(realSet.Overlaps(x)); },
removeDelegate: x => { methodsCalled[12]++; return(realSet.Remove(x)); },
setEqualsDelegate: x => { methodsCalled[13]++; return(realSet.SetEquals(x)); },
symmetricExceptDelegate: x => { methodsCalled[14]++; return(realSet.SymmetricExcept(x)); },
toStringDelegate: null,
tryGetValueDelegate: (int x, out int y) => { methodsCalled[15]++; return(realSet.TryGetValue(x, out y)); },
unionDelegate: x => { methodsCalled[16]++; return(realSet.Union(x)); });
#pragma warning disable IDE0028 // Simplify collection initialization. Intentionally calling .Add separately for clarity
ImmutableSetAdapter <int> set = new ImmutableSetAdapter <int>(backingSet);
#pragma warning restore IDE0028 // Simplify collection initialization.
set.Add(12);
set.Clear();
set.Contains(12);
_ = set.Count;
set.Except(Array.Empty <int>());
set.GetEnumerator();
set.Intersect(Array.Empty <int>());
set.IsProperSubsetOf(Array.Empty <int>());
set.IsProperSupersetOf(Array.Empty <int>());
set.IsSubsetOf(Array.Empty <int>());
set.IsSupersetOf(Array.Empty <int>());
set.Overlaps(Array.Empty <int>());
set.Remove(12);
set.SetEquals(Array.Empty <int>());
set.SymmetricExcept(Array.Empty <int>());
set.TryGetValue(12, out _);
set.Union(Array.Empty <int>());
for (int counter = 0; counter < NumberOfMethods; counter++)
{
Assert.AreEqual(1, methodsCalled[counter]);
}
}
protected override ImmutableHashSet <TChromosome> FilterMeasuredOffspring(
ImmutableHashSet <TChromosome> elite,
IReadOnlyDictionary <TChromosome, double> measured,
int requiredCount,
int remainingCount)
{
return(elite.Union(measured.OrderByDescending(kv => kv.Value)
.Take(remainingCount)
.Select(kv => kv.Key)));
}
public static ImmutableHashSet <T> UnionAll <T>(this IEnumerable <ImmutableHashSet <T> > sets)
{
ImmutableHashSet <T> result = ImmutableHashSet <T> .Empty;
foreach (var set in sets)
{
result = result.Union(set);
}
return(result);
}
public override void VisitPropertyBinding(ResolvedPropertyBinding propertyBinding)
{
var r = propertyBinding.Binding.Binding.GetProperty <RequiredRuntimeResourcesBindingProperty>(ErrorHandlingMode.ReturnNull);
if (r != null)
{
requiredResources = requiredResources.Union(r.Resources);
}
base.VisitPropertyBinding(propertyBinding);
}
protected override void Initialize()
{
using (UnconfiguredProjectAsynchronousTasksService.LoadedProject())
{
// this.IsApplicable may take a project lock, so we can't do it inline with this method
// which is holding a private lock. It turns out that doing it asynchronously isn't a problem anyway,
// so long as we guard against races with the Dispose method.
UnconfiguredProjectAsynchronousTasksService.LoadedProjectAsync(
async delegate
{
await TaskScheduler.Default.SwitchTo(alwaysYield: true);
UnconfiguredProjectAsynchronousTasksService.
UnloadCancellationToken.ThrowIfCancellationRequested();
lock (SyncObject)
{
Verify.NotDisposed(this);
var intermediateBlock = new BufferBlock <
IProjectVersionedValue <
IProjectSubscriptionUpdate> >();
_projectSubscriptionLink = ProjectSubscriptionService.JointRuleSource.SourceBlock.LinkTo(
intermediateBlock,
ruleNames: UnresolvedReferenceRuleNames.Union(ResolvedReferenceRuleNames),
suppressVersionOnlyUpdates: false);
var actionBlock = new ActionBlock <
IProjectVersionedValue <
Tuple <IProjectSubscriptionUpdate,
IProjectCatalogSnapshot,
IProjectSharedFoldersSnapshot> > >
(new Action <
IProjectVersionedValue <
Tuple <IProjectSubscriptionUpdate,
IProjectCatalogSnapshot,
IProjectSharedFoldersSnapshot> > >(
ProjectSubscriptionService_Changed),
new ExecutionDataflowBlockOptions()
{
NameFormat = "ReferencesSubtree Input: {1}"
});
_projectSyncLink = ProjectDataSources.SyncLinkTo(
intermediateBlock.SyncLinkOptions(),
ProjectSubscriptionService.ProjectCatalogSource.SourceBlock.SyncLinkOptions(),
ProjectSubscriptionService.SharedFoldersSource.SourceBlock.SyncLinkOptions(),
actionBlock);
}
},
registerFaultHandler: true);
}
}
private ImmutableHashSet <IIncrementalAnalyzer> Union(ImmutableHashSet <IIncrementalAnalyzer> analyzers)
{
if (analyzers.IsEmpty)
{
return(Analyzers);
}
if (Analyzers.IsEmpty)
{
return(analyzers);
}
return(Analyzers.Union(analyzers));
}
private void SubmissionSuccessfullyExecuted(RemoteExecutionResult result)
{
// only remember the submission if we compiled successfully, otherwise we
// ignore it's id so we don't reference it in the next submission.
_previousSubmissionProjectId = _currentSubmissionProjectId;
// Grab any directive references from it
var compilation = _workspace.CurrentSolution.GetProject(_previousSubmissionProjectId).GetCompilationAsync().Result;
_references = _references.Union(compilation.DirectiveReferences);
// update local search paths - remote paths has already been updated
UpdateLocalPaths(result.NewReferencePaths, result.NewSourcePaths, result.NewWorkingDirectory);
}
public CSharpEditorFormattingService()
{
_autoFormattingTriggerChars = ImmutableHashSet.CreateRange <char>(";}");
// add all auto formatting trigger to supported char
_supportedChars = _autoFormattingTriggerChars.Union("{}#nte:)");
// set up multi words map
_multiWordsMap = ImmutableDictionary.CreateRange(new[]
{
KeyValuePair.Create('n', ImmutableHashSet.Create(SyntaxKind.RegionKeyword, SyntaxKind.EndRegionKeyword)),
KeyValuePair.Create('t', ImmutableHashSet.Create(SyntaxKind.SelectKeyword)),
KeyValuePair.Create('e', ImmutableHashSet.Create(SyntaxKind.WhereKeyword)),
});
}
public CSharpEditorFormattingService()
{
_autoFormattingTriggerChars = ImmutableHashSet.CreateRange<char>(";}");
// add all auto formatting trigger to supported char
_supportedChars = _autoFormattingTriggerChars.Union("{}#nte:)");
// set up multi words map
_multiWordsMap = ImmutableDictionary.CreateRange(new[]
{
KeyValuePair.Create('n', ImmutableHashSet.Create(SyntaxKind.RegionKeyword, SyntaxKind.EndRegionKeyword)),
KeyValuePair.Create('t', ImmutableHashSet.Create(SyntaxKind.SelectKeyword)),
KeyValuePair.Create('e', ImmutableHashSet.Create(SyntaxKind.WhereKeyword)),
});
}
/// <summary>
/// This function is intended to provide a new immutability context that considers the conditional type parameters
/// of the ConditionallyImmutable type being checked as immutable. It is important this is only used in those cases,
/// and not for instance while validating type arguments to an [Immutable] type parameter.
/// </summary>
/// <param name="type">The ConditionallyImmutable type definition being checked</param>
/// <returns></returns>
public ImmutabilityContext WithConditionalTypeParametersAsImmutable(
INamedTypeSymbol type
)
{
if (!m_annotationsContext.Objects.ConditionallyImmutable.IsDefined(type))
{
throw new InvalidOperationException($"{nameof( WithConditionalTypeParametersAsImmutable )} should only be called on ConditionallyImmutable types");
}
var conditionalTypeParameters = type.TypeParameters.Where(p => m_annotationsContext.Objects.OnlyIf.IsDefined(p));
return(new ImmutabilityContext(
annotationsContext: m_annotationsContext,
extraImmutableTypes: m_extraImmutableTypes,
knownImmutableReturns: m_knownImmutableReturns,
conditionalTypeParamemters: m_conditionalTypeParameters.Union(conditionalTypeParameters)
));
}
private static double MinPrice(ImmutableHashSet <Node> nodesIn, Graph graph,
ImmutableHashSet <Node> prohibitedNodes, int setSize)
{
ImmutableDictionary <Node, double> priceOfNode = ImmutableDictionary <Node, double> .Empty;
var usedNodes = nodesIn.Union(prohibitedNodes);
foreach (var node in nodesIn)
{
var price = 0.0;
foreach (var adjacentNode in nodesIn)
{
if (!node.Equals(adjacentNode))
{
price += graph.Weights[node][adjacentNode];
}
}
price += graph.Weights[node].RemoveKeys(usedNodes).Values.PartialSort(setSize - nodesIn.Count).Sum();
priceOfNode = priceOfNode.Add(node, price);
}
foreach (var graphNode in graph.Nodes)
{
if (!usedNodes.Contains(graphNode))
{
var price = 0.0;
foreach (var adjacentNode in nodesIn)
{
price += graph.Weights[graphNode][adjacentNode];
}
if (setSize > nodesIn.Count)
{
price += graph.Weights[graphNode].RemoveKeys(usedNodes).Values.PartialSort(setSize - nodesIn.Count - 1).Sum();
}
priceOfNode = priceOfNode.Add(graphNode, price);
}
}
double inPrice = nodesIn.Sum(n => priceOfNode[n]) / 2.0;
double restPrice = priceOfNode.RemoveRange(nodesIn).Values.PartialSort(setSize - nodesIn.Count).Sum() / 2.0;
return(inPrice + restPrice);
}
private static IEnumerable <ImmutableHashSet <T> > FindCliques(
IGraph <T> graph,
ImmutableHashSet <T> potential_clique,
ImmutableHashSet <T> remaining_nodes,
ImmutableHashSet <T> skip_nodes)
{
if (potential_clique.IsEmpty && skip_nodes.IsEmpty)
{
yield return(remaining_nodes);
}
else
{
var choices = potential_clique.Union(skip_nodes);
ImmutableHashSet <T> pivoted;
if (choices.Count > 0)
{
var pivotVertex = choices.Shuffle().First();
pivoted = potential_clique.Except(graph.Neigbours(pivotVertex));
}
else
{
pivoted = potential_clique;
}
foreach (var v in pivoted)
{
var neighborsOfV = graph.Neigbours(v);
var sub = FindCliques(
graph,
potential_clique.Intersect(neighborsOfV),
remaining_nodes.Add(v),
skip_nodes.Intersect(neighborsOfV));
foreach (var s in sub)
{
yield return(s);
}
potential_clique = potential_clique.Remove(v);
skip_nodes = skip_nodes.Add(v);
}
}
}
public void Process(ImmutableHashSet <EvalStack> set)
{
if (G == null)
{
throw new NullReferenceException("Need to init G for node " + _id);
}
var x = set.Except(_I);
if (!x.IsEmpty)
{
_I = _I.Union(x);
_O = _I.Select(s => G(s)).ToImmutableHashSet();
foreach (var n in _targets)
{
n.Process(_O);
}
}
}
public async Task <ExecutionResult> ExecuteCodeAsync(string text)
{
try
{
if (InteractiveCommands.InCommand)
{
var cmdResult = InteractiveCommands.TryExecuteCommand();
if (cmdResult != null)
{
return(await cmdResult.ConfigureAwait(false));
}
}
var result = await _interactiveHost.ExecuteAsync(text).ConfigureAwait(false);
if (result.Success)
{
// We are not executing a command (the current content type is not "Interactive Command"),
// so the source document should not have been removed.
Debug.Assert(_workspace.CurrentSolution.GetProject(_currentSubmissionProjectId).HasDocuments);
// only remember the submission if we compiled successfully, otherwise we
// ignore it's id so we don't reference it in the next submission.
_previousSubmissionProjectId = _currentSubmissionProjectId;
// Grab any directive references from it
var compilation = await _workspace.CurrentSolution.GetProject(_previousSubmissionProjectId).GetCompilationAsync().ConfigureAwait(false);
_references = _references.Union(compilation.DirectiveReferences);
// update local search paths - remote paths has already been updated
UpdateResolvers(result);
}
return(new ExecutionResult(result.Success));
}
catch (Exception e) when(FatalError.Report(e))
{
throw ExceptionUtilities.Unreachable;
}
}
private static ImmutableHashSet <RemoteObserver> GatherObservers
(IDictionary <string, ImmutableList <Subscription> > dictionary,
string[] ids)
{
ImmutableHashSet <RemoteObserver> result = null;
if (ids != null)
{
result = ImmutableHashSet <RemoteObserver> .Empty;
foreach (string id in ids)
{
if (dictionary.TryGetValue(id, out ImmutableList <Subscription> subscriptions))
{
result = result.Union(subscriptions.Select(x => x.Observer));
}
}
}
return(result);
}
/// <summary>
/// Constructs validator with custom set of allowed and restricted characters.
/// </summary>
/// <param name="configAction">
/// Delegate to configure validator. Used for setting allowed characters and add additional restricted characters.
/// </param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="configAction" /> is null.</exception>
/// <exception cref="ArgumentException">Thrown if you set same characters for allowed and restricted.</exception>
public NoSpecialCharactersValidator(Action <INoSpecialCharactersConfigurationExpression> configAction) : this()
{
if (configAction == null)
{
throw new ArgumentNullException(nameof(configAction));
}
var builder = new NoSpecialCharactersConfigurationBuilder();
configAction(builder);
_configuration = builder.Build();
if (_configuration.AllowedChars != null && _configuration.AllowedChars.Count > 0)
{
_restrictedCharacters = _restrictedCharacters.Except(_configuration.AllowedChars);
}
if (_configuration.RestrictedChars != null && _configuration.RestrictedChars.Count > 0)
{
_restrictedCharacters = _restrictedCharacters.Union(_configuration.RestrictedChars);
}
}
internal ProjectDependencyGraph WithAdditionalProjects(IEnumerable <ProjectId> projectIds)
{
// Track the existence of some new projects. Note this call only adds new ProjectIds, but doesn't add any references. Any caller who wants to add a new project
// with references will first call this, and then call WithAdditionalProjectReferences to add references as well.
// Since we're adding a new project here, there aren't any references to it, or at least not yet. (If there are, they'll be added
// later with WithAdditionalProjectReferences). Thus, the new projects aren't topologically sorted relative to any other project
// and form their own dependency set. Thus, sticking them at the end is fine.
var newTopologicallySortedProjects = _lazyTopologicallySortedProjects;
if (!newTopologicallySortedProjects.IsDefault)
{
newTopologicallySortedProjects = newTopologicallySortedProjects.AddRange(projectIds);
}
var newDependencySets = _lazyDependencySets;
if (!newDependencySets.IsDefault)
{
var builder = newDependencySets.ToBuilder();
foreach (var projectId in projectIds)
{
builder.Add(ImmutableArray.Create(projectId));
}
newDependencySets = builder.ToImmutable();
}
// The rest of the references map is unchanged, since no new references are added in this call.
return(new ProjectDependencyGraph(
_projectIds.Union(projectIds),
referencesMap: _referencesMap,
reverseReferencesMap: _lazyReverseReferencesMap,
transitiveReferencesMap: _transitiveReferencesMap,
reverseTransitiveReferencesMap: _reverseTransitiveReferencesMap,
topologicallySortedProjects: newTopologicallySortedProjects,
dependencySets: newDependencySets));
}
public ComputationalComplexityMetrics Union(ComputationalComplexityMetrics other)
{
if (ReferenceEquals(this, Default))
{
return(other);
}
else if (ReferenceEquals(other, Default))
{
return(this);
}
return(new ComputationalComplexityMetrics(
effectiveLinesOfCode: EffectiveLinesOfCode + other.EffectiveLinesOfCode,
operatorUsageCounts: _operatorUsageCounts + other._operatorUsageCounts,
symbolUsageCounts: _symbolUsageCounts + other._symbolUsageCounts,
constantUsageCounts: _constantUsageCounts + other._constantUsageCounts,
distinctOperatorKinds: _distinctOperatorKinds.Union(other._distinctOperatorKinds),
distinctBinaryOperatorKinds: _distinctBinaryOperatorKinds.Union(other._distinctBinaryOperatorKinds),
distinctUnaryOperatorKinds: _distinctUnaryOperatorKinds.Union(other._distinctUnaryOperatorKinds),
distinctCaseKinds: _distinctCaseKinds.Union(other._distinctCaseKinds),
distinctReferencedSymbols: _distinctReferencedSymbols.Union(other._distinctReferencedSymbols),
distinctReferencedConstants: _distinctReferencedConstants.Union(other._distinctReferencedConstants)));
}
public TestComposition AddAssemblies(IEnumerable <Assembly>?assemblies) => WithAssemblies(Assemblies.Union(assemblies ?? Array.Empty <Assembly>()));
public Task <ImmutableHashSet <TChromosome> > SelectAsync(
ImmutableHashSet <TChromosome> eliteOffspring,
ImmutableHashSet <TChromosome> lastFront,
int expectedOffspringCount,
CancellationToken token)
{
var joined = lastFront.Union(eliteOffspring);
var remainingCount = expectedOffspringCount - eliteOffspring.Count;
var measurable = SelectMeasurableOffspring(eliteOffspring, lastFront)
.ToDictionary(chromosome => chromosome, _ => 0d);
foreach (var objective in _objectives)
{
var orderedGrouped = joined.GroupBy(chromosome =>
_mapper.GetValue(objective, chromosome.Fitness))
.OrderBy(group => group.Key)
.ToImmutableArray();
if (orderedGrouped.Length == 1)
{
continue;
}
var longestDistance = Math.Abs(orderedGrouped.First().Key - orderedGrouped.Last().Key);
var firstLast = orderedGrouped.First().Union(orderedGrouped.Last());
foreach (var chromosome in firstLast)
{
if (!measurable.ContainsKey(chromosome))
{
continue;
}
measurable[chromosome] += longestDistance;
}
if (orderedGrouped.Length == 2)
{
continue;
}
for (var i = 1; i < orderedGrouped.Length - 1; i++)
{
var lower = orderedGrouped[i - 1].Key;
var higher = orderedGrouped[i + 1].Key;
var distance = Math.Abs(higher - lower);
foreach (var chromosome in orderedGrouped[i])
{
if (!measurable.ContainsKey(chromosome))
{
continue;
}
measurable[chromosome] += distance;
}
}
}
var selected = FilterMeasuredOffspring(
eliteOffspring,
measurable,
expectedOffspringCount,
remainingCount);
return(Task.FromResult(selected));
}
public TestComposition AddParts(IEnumerable <Type>?types) => WithParts(Parts.Union(types ?? Array.Empty <Type>()));
public override ImmutableHashSet <ValueTag> Merge(ImmutableHashSet <ValueTag> first, ImmutableHashSet <ValueTag> second)
{
return(first.Union(second));
}
public ImmutableHashSet<Point> PlacePiece(Piece piece, ImmutableHashSet<Point> gameField)
{
return
gameField.Union(piece.Coordinates);
}
private bool TryCreateImportDefinition(Type importingType, ICustomAttributeProvider member, ImmutableHashSet <IImportSatisfiabilityConstraint> importConstraints, [NotNullWhen(true)] out ImportDefinition?importDefinition)
{
Requires.NotNull(importingType, nameof(importingType));
Requires.NotNull(member, nameof(member));
var importAttribute = member.GetFirstAttribute <ImportAttribute>();
var importManyAttribute = member.GetFirstAttribute <ImportManyAttribute>();
// Importing constructors get implied attributes on their parameters.
if (importAttribute == null && importManyAttribute == null && member is ParameterInfo)
{
importAttribute = new ImportAttribute();
}
var sharingBoundaries = ImmutableHashSet.Create <string>();
var sharingBoundaryAttribute = member.GetFirstAttribute <SharingBoundaryAttribute>();
if (sharingBoundaryAttribute != null)
{
Verify.Operation(importingType.IsExportFactoryTypeV2(), Strings.IsExpectedOnlyOnImportsOfExportFactoryOfT, typeof(SharingBoundaryAttribute).Name);
sharingBoundaries = sharingBoundaries.Union(sharingBoundaryAttribute.SharingBoundaryNames);
}
if (member is PropertyInfo importingMember && importingMember.SetMethod == null)
{
// MEFv2 quietly ignores such importing members.
importDefinition = null;
return(false);
}
if (importAttribute != null)
{
this.ThrowOnInvalidImportingMemberOrParameter(member, isImportMany: false);
Type contractType = GetTypeIdentityFromImportingType(importingType, importMany: false);
if (contractType.IsAnyLazyType() || contractType.IsExportFactoryTypeV2())
{
contractType = contractType.GetTypeInfo().GetGenericArguments()[0];
}
importConstraints = importConstraints
.Union(this.GetMetadataViewConstraints(importingType, importMany: false))
.Union(GetExportTypeIdentityConstraints(contractType));
importDefinition = new ImportDefinition(
string.IsNullOrEmpty(importAttribute.ContractName) ? GetContractName(contractType) : importAttribute.ContractName,
importAttribute.AllowDefault ? ImportCardinality.OneOrZero : ImportCardinality.ExactlyOne,
GetImportMetadataForGenericTypeImport(contractType),
importConstraints,
sharingBoundaries);
return(true);
}
else if (importManyAttribute != null)
{
this.ThrowOnInvalidImportingMemberOrParameter(member, isImportMany: true);
Type contractType = GetTypeIdentityFromImportingType(importingType, importMany: true);
importConstraints = importConstraints
.Union(this.GetMetadataViewConstraints(importingType, importMany: true))
.Union(GetExportTypeIdentityConstraints(contractType));
importDefinition = new ImportDefinition(
string.IsNullOrEmpty(importManyAttribute.ContractName) ? GetContractName(contractType) : importManyAttribute.ContractName,
ImportCardinality.ZeroOrMore,
GetImportMetadataForGenericTypeImport(contractType),
importConstraints,
sharingBoundaries);
return(true);
}
else
{
importDefinition = null;
return(false);
}
}
public TestComposition AddExcludedPartTypes(IEnumerable <Type>?types) => WithExcludedPartTypes(ExcludedPartTypes.Union(types ?? Array.Empty <Type>()));
/// <inheritdoc />
public IImmutableSet <T> Union(IEnumerable <T> other)
{
return(new SetEqualedReadOnlySet <T>(_set.Union(other)));
}
public static ImmutableHashSet <T> AddRange <T>(this ImmutableHashSet <T> set, IEnumerable <T> values)
{
return(set.Union(values));
}
/// <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;
var mscorlibRef = metadataService.GetReference(typeof(object).Assembly.Location, MetadataReferenceProperties.Assembly);
var interactiveHostObjectRef = metadataService.GetReference(typeof(InteractiveScriptGlobals).Assembly.Location, MetadataReferenceProperties.Assembly);
_references = ImmutableHashSet.Create<MetadataReference>(mscorlibRef, interactiveHostObjectRef);
_rspImports = ImmutableArray<string>.Empty;
_initialScriptFileOpt = null;
ReferenceSearchPaths = ImmutableArray<string>.Empty;
SourceSearchPaths = ImmutableArray<string>.Empty;
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 rspDirectory = Path.GetDirectoryName(_responseFilePath);
var args = this.CommandLineParser.Parse(new[] { "@" + _responseFilePath }, rspDirectory, RuntimeEnvironment.GetRuntimeDirectory(), null);
if (args.Errors.Length == 0)
{
var metadataResolver = CreateMetadataReferenceResolver(metadataService, args.ReferencePaths, rspDirectory);
var sourceResolver = CreateSourceReferenceResolver(args.SourcePaths, rspDirectory);
// ignore unresolved references, they will be reported in the interactive window:
var rspReferences = args.ResolveMetadataReferences(metadataResolver).Where(r => !(r is UnresolvedMetadataReference));
_initialScriptFileOpt = args.SourceFiles.IsEmpty ? null : args.SourceFiles[0].Path;
ReferenceSearchPaths = args.ReferencePaths;
SourceSearchPaths = args.SourcePaths;
_references = _references.Union(rspReferences);
_rspImports = CommandLineHelpers.GetImports(args);
}
}
_metadataReferenceResolver = CreateMetadataReferenceResolver(metadataService, ReferenceSearchPaths, _initialWorkingDirectory);
_sourceReferenceResolver = CreateSourceReferenceResolver(SourceSearchPaths, _initialWorkingDirectory);
// create the first submission project in the workspace after reset:
if (_currentSubmissionBuffer != null)
{
AddSubmission(_currentTextView, _currentSubmissionBuffer, this.LanguageName);
}
}
