public ImmutableDictionary<string, object> PrepareMetadata(ImmutableDictionary<string, object> metadata)
{
if (!metadata.ContainsKey("_enableSearch"))
{
metadata = metadata.Add("_enableSearch", true);
}
return metadata;
}
private static Dictionary <ITextBuffer, DiffResult> ProcessNewTagTrees(
ImmutableArray <DocumentSnapshotSpan> spansToTag,
ImmutableDictionary <ITextBuffer, TagSpanIntervalTree <TTag> > oldTagTrees,
ImmutableDictionary <ITextBuffer, TagSpanIntervalTree <TTag> > newTagTrees,
CancellationToken cancellationToken)
{
using (Logger.LogBlock(FunctionId.Tagger_TagSource_ProcessNewTags, cancellationToken))
{
var bufferToChanges = new Dictionary <ITextBuffer, DiffResult>();
foreach (var(latestBuffer, latestSpans) in newTagTrees)
{
var snapshot = spansToTag.First(s => s.SnapshotSpan.Snapshot.TextBuffer == latestBuffer).SnapshotSpan.Snapshot;
if (oldTagTrees.TryGetValue(latestBuffer, out var previousSpans))
{
var difference = ComputeDifference(snapshot, latestSpans, previousSpans);
bufferToChanges[latestBuffer] = difference;
}
else
{
// It's a new buffer, so report all spans are changed
bufferToChanges[latestBuffer] = new DiffResult(added: new(latestSpans.GetSpans(snapshot).Select(t => t.Span)), removed: null);
}
}
foreach (var(oldBuffer, previousSpans) in oldTagTrees)
{
if (!newTagTrees.ContainsKey(oldBuffer))
{
// This buffer disappeared, so let's notify that the old tags are gone
bufferToChanges[oldBuffer] = new DiffResult(added: null, removed: new(previousSpans.GetSpans(oldBuffer.CurrentSnapshot).Select(t => t.Span)));
}
}
return(bufferToChanges);
}
}
> MergeDiagnosticAnalyzerMap(
ImmutableDictionary <object, ImmutableArray <DiagnosticAnalyzer> > map1,
ImmutableDictionary <object, ImmutableArray <DiagnosticAnalyzer> > map2
)
{
var current = map1;
var seen = new HashSet <DiagnosticAnalyzer>(map1.Values.SelectMany(v => v));
foreach (var(referenceIdentity, analyzers) in map2)
{
if (map1.ContainsKey(referenceIdentity))
{
continue;
}
current = current.Add(
referenceIdentity,
analyzers.Where(a => seen.Add(a)).ToImmutableArray()
);
}
return(current);
}
private void UpdateCompilerAnalyzerMapIfNeeded(
string language,
ImmutableArray <DiagnosticAnalyzer> analyzers
)
{
if (_compilerDiagnosticAnalyzerMap.ContainsKey(language))
{
return;
}
foreach (var analyzer in analyzers)
{
if (analyzer.IsCompilerAnalyzer())
{
ImmutableInterlocked.GetOrAdd(
ref _compilerDiagnosticAnalyzerMap,
language,
analyzer
);
return;
}
}
}
public OcarinaSelector(ModeData data,
ImmutableDictionary <ModeId, ModeData> modesData,
ImmutableDictionary <ModeId, Func <DeskPiMode, DeskPiMode> > modes,
ImmutableDictionary <KeyId, Note> keyToNote,
Func <DeskPiMode, DeskPiMode> createIntroMode)
: base(() => new OcarinaSelector(data, modesData, modes, keyToNote, createIntroMode), data)
{
CheckOrphans(modesData, modes);
this.songTrie = new Trie <Note, Func <DeskPiMode, DeskPiMode> >();
foreach (var entry in modesData)
{
if (modes.ContainsKey(entry.Key))
{
songTrie = songTrie.Insert(entry.Value.Song.Notes, modes[entry.Key]);
}
}
this.keyToNote = keyToNote;
this.createIntroMode = createIntroMode;
this.receivedNotes = ImmutableList <Note> .Empty;
}
public bool Equals(CompositeCacheKey other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
if (BaseCacheKey != other.BaseCacheKey)
{
return(false);
}
var allOthersMatch = other.SubKeys.All(kvp =>
SubKeys.ContainsKey(kvp.Key) &&
kvp.Value == SubKeys[kvp.Key]
);
var otherContainsAll = SubKeys.All(kvp => other.SubKeys.ContainsKey(kvp.Key));
return(allOthersMatch && otherContainsAll);
}
internal virtual int?Step()
{
var instr = ReadNext();
if (instr == 0)
{
return(null);
}
var opCode = (OpCode)instr;
if (!opCodes.ContainsKey(opCode))
{
throw new InvalidOperationException(string.Format("Unknown opcode: 0x{0}", instr.ToString("X2")));
}
opCodes[opCode]();
// TODO: Count costs...
var cyclesSpent = 1;
return(cyclesSpent);
}
private ImmutableDictionary <string, DiagnosticDescriptor> LoadDiagnosticsById()
{
ImmutableDictionary <string, DiagnosticDescriptor> .Builder diagnosticsById = ImmutableDictionary.CreateBuilder <string, DiagnosticDescriptor>();
diagnosticsById.AddRange(Analyzers
.SelectMany(f => f.SupportedDiagnostics)
.Distinct(DiagnosticDescriptorComparer.Id)
.OrderBy(f => f, DiagnosticDescriptorComparer.Id)
.Select(f => new KeyValuePair <string, DiagnosticDescriptor>(f.Id, f)));
foreach (CodeFixProvider fixer in Fixers)
{
foreach (string diagnosticId in fixer.FixableDiagnosticIds)
{
if (!diagnosticsById.ContainsKey(diagnosticId))
{
diagnosticsById[diagnosticId] = null;
}
}
}
return(diagnosticsById.ToImmutable());
}
public InterceptedProjectProperties(ImmutableArray <Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata> > valueProviders, IProjectProperties defaultProperties)
: base(defaultProperties)
{
Requires.NotNullOrEmpty(valueProviders, nameof(valueProviders));
ImmutableDictionary <string, Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata> > .Builder builder = ImmutableDictionary.CreateBuilder <string, Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata> >(StringComparers.PropertyNames);
foreach (Lazy <IInterceptingPropertyValueProvider, IInterceptingPropertyValueProviderMetadata> valueProvider in valueProviders)
{
string[] propertyNames = valueProvider.Metadata.PropertyNames;
foreach (var propertyName in propertyNames)
{
Requires.Argument(!string.IsNullOrEmpty(propertyName), nameof(valueProvider), "A null or empty property name was found");
// CONSIDER: Allow duplicate intercepting property value providers for same property name.
Requires.Argument(!builder.ContainsKey(propertyName), nameof(valueProviders), "Duplicate property value providers for same property name");
builder.Add(propertyName, valueProvider);
}
}
_valueProviders = builder.ToImmutable();
}
public override string GetMangledStringName(string literal)
{
Debug.Assert(OrdinalReceived);
string mangledName;
if (_mangledStringLiterals.TryGetValue(literal, out mangledName))
{
return(mangledName);
}
mangledName = SanitizeNameWithHash(literal);
lock (this)
{
if (!_mangledStringLiterals.ContainsKey(literal))
{
_mangledStringLiterals = _mangledStringLiterals.Add(literal, mangledName);
}
}
return(mangledName);
}
public void Set(string key, object val)
{
object old = Get <object> (key);
if (val == null)
{
//avoid emitting the event if not necessary
if (old == null)
{
return;
}
if (properties.ContainsKey(key))
{
properties = properties.Remove(key);
}
}
else
{
//avoid emitting the event if not necessary
if (val.Equals(old))
{
return;
}
properties = properties.SetItem(key, val);
if (!val.GetType().IsClass || (val is string))
{
if (defaultValues.ContainsKey(key))
{
if (defaultValues[key] == val)
{
properties = properties.Remove(key);
}
}
}
}
OnPropertyChanged(new PropertyChangedEventArgs(key, old, val));
}
protected override IInPacket CreatePacket(Stream stream, out int packetSize)
{
packetSize = 0;
if (stream.Length - stream.Position < ClientPacketHeaderSize)
{
return(null);
}
var initialPosition = stream.Position;
var header = new byte[ClientPacketHeaderSize];
stream.Read(header, 0, header.Length);
// the size is encoded in big endian and doesn't include the size of the size itself
var size = sizeof(ushort) + BitConverter.ToUInt16(new[] { header[1], header[0] }, 0);
var ordinal = BitConverter.ToUInt32(header, sizeof(ushort));
packetSize = size;
if (stream.Length - initialPosition < size)
{
return(null);
}
var opcode = (ShardClientOpcode)ordinal;
if (packetMap.ContainsKey(opcode))
{
Console.WriteLine($"received packet from client: type = {opcode}, total size = {size}");
return((IInPacket)Activator.CreateInstance(packetMap[opcode]));
}
else
{
Console.WriteLine($"received unimplemented packet from client: type = {opcode} (0x{(ushort)opcode:x4}), total size = {size}");
return(new UnimplementedPacket(size - ClientPacketHeaderSize));
}
}
private static ImmutableDictionary <Language, LanguageConfig> ValidateLanguages(ImmutableDictionary <Language, LanguageConfig> languages)
{
var errors = new List <ValidationError>();
foreach (var languageConfig in languages.Values)
{
foreach (var fallback in languageConfig.LanguageFallbacks)
{
if (!languages.ContainsKey(fallback))
{
var message = $"Config for language '{languageConfig.Language.Iso2Code}' contains unsupported fallback language '{fallback.Iso2Code}'";
errors.Add(new ValidationError(message));
}
}
}
if (errors.Count > 0)
{
throw new ValidationException("Cannot configure language.", errors);
}
return(languages);
}
/// <summary>
/// Returns true if this cross-targeting aggregate project context has the same set of target frameworks and active target framework as the given active and known configurations.
/// </summary>
public bool HasMatchingTargetFrameworks(ProjectConfiguration activeProjectConfiguration,
IEnumerable <ProjectConfiguration> knownProjectConfigurations)
{
Assumes.True(IsCrossTargeting);
Assumes.True(activeProjectConfiguration.IsCrossTargeting());
Assumes.True(knownProjectConfigurations.All(c => c.IsCrossTargeting()));
ITargetFramework activeTargetFramework = TargetFrameworkProvider.GetTargetFramework(activeProjectConfiguration.Dimensions[ConfigurationGeneral.TargetFrameworkProperty]);
if (!_activeTargetFramework.Equals(activeTargetFramework))
{
// Active target framework is different.
return(false);
}
var targetFrameworks = knownProjectConfigurations.Select(
c => c.Dimensions[ConfigurationGeneral.TargetFrameworkProperty]).ToImmutableHashSet();
if (targetFrameworks.Count != _configuredProjectContextsByTargetFramework.Count)
{
// Different number of target frameworks.
return(false);
}
foreach (string targetFrameworkMoniker in targetFrameworks)
{
ITargetFramework targetFramework = TargetFrameworkProvider.GetTargetFramework(targetFrameworkMoniker);
if (!_configuredProjectContextsByTargetFramework.ContainsKey(targetFramework))
{
// Differing TargetFramework
return(false);
}
}
return(true);
}
public Task <(string id, object state)> NewResourceAsync(
string type, string name, ImmutableDictionary <string, object> inputs, string?provider, string?id)
{
var outputs = ImmutableDictionary.CreateBuilder <string, object>();
// Forward all input parameters as resource outputs, so that we could test them.
outputs.AddRange(inputs);
// <-- We'll customize the mocks here
// Set the name to resource name if it's not set explicitly in inputs.
if (!inputs.ContainsKey("name"))
{
outputs.Add("name", name);
}
if (type == "azure-native:storage:StorageAccount")
{
// ... set its web endpoint property.
// Normally this would be calculated by Azure, so we have to mock it.
outputs.Add("primaryEndpoints", new Dictionary <string, object?>
{
{ "blob", "BlobEndpoint" },
{ "dfs", "DfsEndpoint" },
{ "file", "FileEndpoint" },
{ "internetEndpoints", null },
{ "microsoftEndpoints", null },
{ "queue", "QueueEndpoint" },
{ "table", "TableEndpoint" },
{ "web", $"https://{name}.web.core.windows.net" },
});
}
// Default the resource ID to `{name}_id`.
id ??= $"{name}_id";
return(Task.FromResult((id, (object)outputs)));
}
// Internal, for test use -- normal code should use the factory methods
internal DependenciesSnapshot(
TargetFramework activeTargetFramework,
ImmutableDictionary <TargetFramework, TargetedDependenciesSnapshot> dependenciesByTargetFramework)
{
Requires.NotNull(activeTargetFramework, nameof(activeTargetFramework));
Requires.NotNull(dependenciesByTargetFramework, nameof(dependenciesByTargetFramework));
#if false
// The validation in this #if/#endif block is sound in theory, however is causing quite a few NFEs.
// For example https://github.com/dotnet/project-system/issues/6656.
//
// We have disabled it for now. The consequence of this test failing is that dependencies added to
// the tree are not exposed via extensibility APIs such as DTE/VSLangProj.
//
// At some point we should revisit how the dependencies tree models its target frameworks, likely
// as part of https://github.com/dotnet/project-system/issues/6183.
// We have seen NFEs where the active target framework is unsupported. Skipping validation in such cases is better than faulting the dataflow.
if (!activeTargetFramework.Equals(TargetFramework.Empty) &&
!activeTargetFramework.Equals(TargetFramework.Unsupported) &&
!dependenciesByTargetFramework.ContainsKey(activeTargetFramework))
{
string keyNames = dependenciesByTargetFramework.Count == 0
? "no items"
: string.Join(", ", dependenciesByTargetFramework.Keys.Select(t => $"\"{t.TargetFrameworkMoniker}\""));
Requires.Argument(
false,
nameof(activeTargetFramework),
$"Value \"{activeTargetFramework.TargetFrameworkMoniker}\" is unexpected. Must be a key in {nameof(dependenciesByTargetFramework)}, which contains {keyNames}.");
}
#endif
ActiveTargetFramework = activeTargetFramework;
DependenciesByTargetFramework = dependenciesByTargetFramework;
}
protected EnumToStringUsingTranslationMappingSerializer(Dictionary <T, string> translation)
{
_translation = translation.ToImmutableDictionary();
foreach (T enumValue in Enum.GetValues(typeof(T)).OfType <T>())
{
if (!_translation.ContainsKey(enumValue))
{
throw new ArgumentException(
$"enum translation must be exhaustive, but '{enumValue}' is missing.");
}
}
var translationBack = new Dictionary <string, T>();
foreach ((T key, string value) in _translation)
{
if (translationBack.ContainsKey(value))
{
throw new ArgumentException(
$"enum translation values must be unique, but '{value}' was used multiple times");
}
translationBack[value] = key;
}
_translationBack = translationBack.ToImmutableDictionary();
}
public State(ImmutableDictionary <Language, LanguageConfig> languages, LanguageConfig master)
{
foreach (var languageConfig in languages.Values)
{
foreach (var fallback in languageConfig.LanguageFallbacks)
{
if (!languages.ContainsKey(fallback))
{
var message = $"Config for language '{languageConfig.Language.Iso2Code}' contains unsupported fallback language '{fallback.Iso2Code}'";
throw new InvalidOperationException(message);
}
}
}
Languages = languages;
if (master == null)
{
throw new InvalidOperationException("Config has no master language.");
}
this.Master = master;
}
private void ProcessLambdaOrLocalFunctionInvocation(IMethodSymbol targetMethod, IOperation invocation)
{
Debug.Assert(targetMethod.MethodKind == MethodKind.LambdaMethod || targetMethod.MethodKind == MethodKind.LocalFunction);
// Lambda and local function invocations can access captured variables.
if (_hazardousParameterUsageBuilderOpt != null &&
TryGetInterproceduralAnalysisResult(invocation, out var invokedMethodAnalysisResult))
{
var notValidatedLocations = CurrentAnalysisData.Keys.Where(IsNotOrMaybeValidatedLocation);
if (notValidatedLocations.Any())
{
var hazardousParameterUsagesInInvokedMethod = invokedMethodAnalysisResult.HazardousParameterUsages;
foreach (var kvp in hazardousParameterUsagesInInvokedMethod)
{
var parameter = kvp.Key;
var syntaxNode = kvp.Value;
if (!_hazardousParameterUsageBuilderOpt.ContainsKey(parameter))
{
HandleHazardousOperation(syntaxNode, notValidatedLocations.Where(l => l.SymbolOpt == parameter));
}
}
}
}
}
protected override bool CanBeChanged(SyntaxNode node, SemanticModel semanticModel) => NodeToDeclarationName.ContainsKey(node.Kind()) && VerifyCanBeChangedBySymbol(node, semanticModel);
public bool HasOption(string optionKey)
{
return(options.ContainsKey(optionKey));
}
public bool ContainsKey(TKey key) => _forwardMap.ContainsKey(key);
public bool ContainsValue(TValue value) => _backwardMap.ContainsKey(value);
public bool HasType(ResourceScope scopeType, ResourceTypeReference typeReference) => typeDictionary.ContainsKey(typeReference);
public void ContainsKey_Test()
{
Dictionary<int, string> _dictionary = new Dictionary<int, string>
{
{1, "aabb"},
{2, "bbcc"},
{3, "ccdd"}
};
ImmutableDictionary<int, string> _immutableDictionary = new ImmutableDictionary<int, string>(_dictionary);
Assert.IsTrue(_immutableDictionary.ContainsKey(1));
}
/// <summary>
/// Returns if <see cref="DisableType"/> and objectId are disabled.
/// </summary>
public bool IsDisabled(DisableType type, uint objectId)
{
ulong hash = Hash(type, objectId);
return(disables.ContainsKey(hash));
}
private static ProjectDependencyGraph CreateDependencyGraph(
IReadOnlyList<ProjectId> projectIds,
ImmutableDictionary<ProjectId, ProjectState> projectStates)
{
var map = projectStates.Values.Select(state => new KeyValuePair<ProjectId, ImmutableHashSet<ProjectId>>(
state.Id,
state.ProjectReferences.Where(pr => projectStates.ContainsKey(pr.ProjectId)).Select(pr => pr.ProjectId).ToImmutableHashSet()))
.ToImmutableDictionary();
return new ProjectDependencyGraph(projectIds.ToImmutableArray(), map);
}
public bool ContainsKey(string key)
{
return(_dictionary.ContainsKey(key));
}
private static bool MethodCalledFromDispose(ImmutableDictionary<INamedTypeSymbol, ImmutableHashSet<IMethodSymbol>> disposeMethodsCalledFromDispose, IMethodSymbol dispose)
{
return disposeMethodsCalledFromDispose.ContainsKey(dispose.ContainingType) &&
disposeMethodsCalledFromDispose[dispose.ContainingType].Contains(dispose);
}
public override bool CanConvert(Type typeToConvert) => typeToConvert.IsGenericType && converters.ContainsKey(typeToConvert.GetGenericTypeDefinition());
public bool ContainsEdge(TEdgeId edgeId) => _edges.ContainsKey(edgeId);
private static ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> MergeDiagnosticAnalyzerMap(
ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> map1, ImmutableDictionary<object, ImmutableArray<DiagnosticAnalyzer>> map2)
{
var current = map1;
var seen = new HashSet<DiagnosticAnalyzer>(map1.Values.SelectMany(v => v));
foreach (var kv in map2)
{
var referenceIdentity = kv.Key;
var analyzers = kv.Value;
if (map1.ContainsKey(referenceIdentity))
{
continue;
}
current = current.Add(referenceIdentity, analyzers.Where(a => seen.Add(a)).ToImmutableArray());
}
return current;
}
public bool HasParameter(string parameterKey)
{
return(parameters.ContainsKey(parameterKey));
}
/// <summary>
/// TBD
/// </summary>
/// <param name="message">TBD</param>
protected override void OnReceive(object message)
{
var state = message as ClusterEvent.CurrentClusterState;
if (state != null)
{
_leader = state.Leader != null && state.Leader.Equals(SelfAddress);
foreach (var m in state.Unreachable)
{
UnreachableMember(m);
}
return;
}
var unreachableMember = message as ClusterEvent.UnreachableMember;
if (unreachableMember != null)
{
UnreachableMember(unreachableMember.Member);
return;
}
var reachableMember = message as ClusterEvent.ReachableMember;
if (reachableMember != null)
{
Remove(reachableMember.Member.UniqueAddress);
return;
}
var memberRemoved = message as ClusterEvent.MemberRemoved;
if (memberRemoved != null)
{
Remove(memberRemoved.Member.UniqueAddress);
return;
}
var leaderChanged = message as ClusterEvent.LeaderChanged;
if (leaderChanged != null)
{
_leader = leaderChanged.Leader != null && leaderChanged.Leader.Equals(SelfAddress);
if (_leader)
{
foreach (var node in _pendingUnreachable)
{
Down(node.Address);
}
_pendingUnreachable = ImmutableHashSet.Create <UniqueAddress>();
}
return;
}
var unreachableTimeout = message as AutoDown.UnreachableTimeout;
if (unreachableTimeout != null)
{
if (_scheduledUnreachable.ContainsKey(unreachableTimeout.Node))
{
_scheduledUnreachable = _scheduledUnreachable.Remove(unreachableTimeout.Node);
DownOrAddPending(unreachableTimeout.Node);
}
return;
}
}
/// <summary>
/// If given <param name="type"/> is an <see cref="EcmaType"/> precompute its mangled type name
/// along with all the other types from the same module as <param name="type"/>.
/// Otherwise, it is a constructed type and to the EcmaType's mangled name we add a suffix to
/// show what kind of constructed type it is (e.g. appending __Array for an array type).
/// </summary>
/// <param name="type">Type to mangled</param>
/// <returns>Mangled name for <param name="type"/>.</returns>
private string ComputeMangledTypeName(TypeDesc type)
{
if (type is EcmaType)
{
EcmaType ecmaType = (EcmaType)type;
string prependAssemblyName = SanitizeName(((EcmaAssembly)ecmaType.EcmaModule).GetName().Name);
var deduplicator = new HashSet <string>();
// Add consistent names for all types in the module, independent on the order in which
// they are compiled
lock (this)
{
if (!_mangledTypeNames.ContainsKey(type))
{
foreach (MetadataType t in ((EcmaType)type).EcmaModule.GetAllTypes())
{
string name = t.GetFullName();
// Include encapsulating type
DefType containingType = t.ContainingType;
while (containingType != null)
{
name = containingType.GetFullName() + "_" + name;
containingType = containingType.ContainingType;
}
name = SanitizeName(name, true);
name = prependAssemblyName + "_" + name;
// Ensure that name is unique and update our tables accordingly.
name = DisambiguateName(name, deduplicator);
deduplicator.Add(name);
_mangledTypeNames = _mangledTypeNames.Add(t, name);
}
}
}
return(_mangledTypeNames[type]);
}
string mangledName;
switch (type.Category)
{
case TypeFlags.Array:
case TypeFlags.SzArray:
mangledName = GetMangledTypeName(((ArrayType)type).ElementType) + "__";
if (type.IsMdArray)
{
mangledName += NestMangledName("ArrayRank" + ((ArrayType)type).Rank.ToStringInvariant());
}
else
{
mangledName += NestMangledName("Array");
}
break;
case TypeFlags.ByRef:
mangledName = GetMangledTypeName(((ByRefType)type).ParameterType) + NestMangledName("ByRef");
break;
case TypeFlags.Pointer:
mangledName = GetMangledTypeName(((PointerType)type).ParameterType) + NestMangledName("Pointer");
break;
default:
// Case of a generic type. If `type' is a type definition we use the type name
// for mangling, otherwise we use the mangling of the type and its generic type
// parameters, e.g. A <B> becomes A_<___B_>_ in RyuJIT compilation, or A_A___B_V_
// in C++ compilation.
var typeDefinition = type.GetTypeDefinition();
if (typeDefinition != type)
{
mangledName = GetMangledTypeName(typeDefinition);
var inst = type.Instantiation;
string mangledInstantiation = "";
for (int i = 0; i < inst.Length; i++)
{
string instArgName = GetMangledTypeName(inst[i]);
if (i > 0)
{
mangledInstantiation += "__";
}
mangledInstantiation += instArgName;
}
mangledName += NestMangledName(mangledInstantiation);
}
else
{
mangledName = SanitizeName(((DefType)type).GetFullName(), true);
}
break;
}
lock (this)
{
// Ensure that name is unique and update our tables accordingly.
if (!_mangledTypeNames.ContainsKey(type))
{
_mangledTypeNames = _mangledTypeNames.Add(type, mangledName);
}
}
return(mangledName);
}
private Transaction GetPreviousTransaction(Block block, int txIndex, TxOutputKey prevTxOutputKey, ImmutableDictionary<UInt256, UnspentTx> utxo, ImmutableDictionary<UInt256, ImmutableHashSet<int>> newTransactions)
{
if (newTransactions.ContainsKey(prevTxOutputKey.TxHash))
{
var eligible = newTransactions[prevTxOutputKey.TxHash].Where(x => x < txIndex).ToList();
if (eligible.Count > 0)
{
var max = eligible.Max();
if (max >= block.Transactions.Length)
throw new Exception();
var prevTx1 = block.Transactions[max];
if (prevTx1.Hash != prevTxOutputKey.TxHash)
throw new Exception();
return prevTx1;
}
}
// find previous transaction
if (!utxo.ContainsKey(prevTxOutputKey.TxHash))
throw new MissingDataException(DataType.Transaction, prevTxOutputKey.TxHash);
var prevTxKey = utxo[prevTxOutputKey.TxHash].ToTxKey();
var prevTx2 = this.CacheContext.GetTransaction(prevTxKey);
if (prevTx2.Hash != prevTxOutputKey.TxHash)
throw new Exception();
return prevTx2;
}