public ImmutableDictionary<string, object> PrepareMetadata(ImmutableDictionary<string, object> metadata) { if (!metadata.ContainsKey("_enableSearch")) { metadata = metadata.Add("_enableSearch", true); } return metadata; }
public void ImmutableDictionary_AddTest() { Dictionary<int, string> dictionary = new Dictionary<int, string> { {1,"asaas"}, {2,"sasas"}, {3,"tak"} }; ImmutableDictionary<int, string> test = new ImmutableDictionary<int, string>(dictionary); test.Add(3, "dddfd"); }
public static CompletionItem Create( string displayText, TextSpan span, Glyph? glyph = null, ImmutableArray<SymbolDisplayPart> description = default(ImmutableArray<SymbolDisplayPart>), string sortText = null, string filterText = null, bool preselect = false, bool showsWarningIcon = false, bool shouldFormatOnCommit = false, bool isArgumentName = false, ImmutableDictionary<string, string> properties = null, ImmutableArray<string> tags = default(ImmutableArray<string>), CompletionItemRules rules = null) { tags = tags.IsDefault ? ImmutableArray<string>.Empty : tags; if (glyph != null) { // put glyph tags first tags = GlyphTags.GetTags(glyph.Value).AddRange(tags); } if (showsWarningIcon) { tags = tags.Add(CompletionTags.Warning); } if (isArgumentName) { tags = tags.Add(CompletionTags.ArgumentName); } properties = properties ?? ImmutableDictionary<string, string>.Empty; if (!description.IsDefault && description.Length > 0) { properties = properties.Add("Description", EncodeDescription(description)); } rules = rules ?? CompletionItemRules.Default; rules = rules.WithPreselect(preselect) .WithFormatOnCommit(shouldFormatOnCommit); return CompletionItem.Create( displayText: displayText, filterText: filterText, sortText: sortText, span: span, properties: properties, tags: tags, rules: rules); }
public static CompletionItem Create( string displayText, Glyph? glyph = null, ImmutableArray<SymbolDisplayPart> description = default(ImmutableArray<SymbolDisplayPart>), string sortText = null, string filterText = null, int? matchPriority = null, bool showsWarningIcon = false, bool shouldFormatOnCommit = false, ImmutableDictionary<string, string> properties = null, ImmutableArray<string> tags = default(ImmutableArray<string>), CompletionItemRules rules = null) { tags = tags.NullToEmpty(); if (glyph != null) { // put glyph tags first tags = GlyphTags.GetTags(glyph.Value).AddRange(tags); } if (showsWarningIcon) { tags = tags.Add(CompletionTags.Warning); } properties = properties ?? ImmutableDictionary<string, string>.Empty; if (!description.IsDefault && description.Length > 0) { properties = properties.Add("Description", EncodeDescription(description)); } rules = rules ?? CompletionItemRules.Default; rules = rules.WithMatchPriority(matchPriority.GetValueOrDefault()) .WithFormatOnCommit(shouldFormatOnCommit); return CompletionItem.Create( displayText: displayText, filterText: filterText, sortText: sortText, properties: properties, tags: tags, rules: rules); }
public PointsToAbstractValue GetOrCreateDefaultValue(AnalysisEntity analysisEntity) { if (!_defaultPointsToValueMapBuilder.TryGetValue(analysisEntity, out PointsToAbstractValue value)) { if (analysisEntity.SymbolOpt?.Kind == SymbolKind.Local || analysisEntity.SymbolOpt is IParameterSymbol parameter && parameter.RefKind == RefKind.Out || analysisEntity.CaptureIdOpt != null) { return(PointsToAbstractValue.Undefined); } else if (!analysisEntity.Type.IsReferenceTypeOrNullableValueType()) { return(PointsToAbstractValue.NoLocation); } else if (analysisEntity.HasUnknownInstanceLocation) { return(PointsToAbstractValue.Unknown); } value = PointsToAbstractValue.Create(AbstractLocation.CreateAnalysisEntityDefaultLocation(analysisEntity), mayBeNull: true); _trackedEntitiesBuilder.AllEntities.Add(analysisEntity); _defaultPointsToValueMapBuilder.Add(analysisEntity, value); }
public static ImmutableDictionary <CaptureId, FlowCaptureKind> CreateLValueFlowCaptures(ControlFlowGraph cfg) { // This method identifies flow capture reference operations that are target of an assignment // and marks them as lvalue flow captures. // Note that currently the control flow graph does not contain flow captures // that are r-value captures at some point and l-values captures at other point in // the flow graph. The debug only asserts in this method ensure this invariant. // If these asserts fire, we should adjust this algorithm. ImmutableDictionary <CaptureId, FlowCaptureKind> .Builder lvalueFlowCaptureIdBuilder = null; #if DEBUG var rvalueFlowCaptureIds = new HashSet <CaptureId>(); #endif foreach (var flowCaptureReference in cfg.DescendantOperations <IFlowCaptureReferenceOperation>(OperationKind.FlowCaptureReference)) { if (flowCaptureReference.Parent is IAssignmentOperation assignment && assignment.Target == flowCaptureReference || flowCaptureReference.IsInLeftOfDeconstructionAssignment(out _)) { lvalueFlowCaptureIdBuilder = lvalueFlowCaptureIdBuilder ?? ImmutableDictionary.CreateBuilder <CaptureId, FlowCaptureKind>(); var captureKind = flowCaptureReference.Parent is ICompoundAssignmentOperation ? FlowCaptureKind.LValueAndRValueCapture : FlowCaptureKind.LValueCapture; lvalueFlowCaptureIdBuilder.Add(flowCaptureReference.Id, captureKind); }
static EnumHelper() { LocalAssembly = typeof(EnumHelper).Assembly; CultureInfo currentCulture = CultureInfo.CurrentCulture; ImmutableDictionary <Type, EnumField[]> .Builder builder = ImmutableDictionary.CreateBuilder <Type, EnumField[]>(); ImmutableDictionary <FieldInfo, ImmutableDictionary <CultureInfo, string> > .Builder builder2 = ImmutableDictionary.CreateBuilder <FieldInfo, ImmutableDictionary <CultureInfo, string> >(); TypeInfo[] array = LocalAssembly.DefinedTypes.Where((TypeInfo x) => x.IsEnum).ToArray(); foreach (TypeInfo typeInfo in array) { EnumField[] enumFieldsInner = GetEnumFieldsInner(typeInfo, currentCulture); builder.Add(typeInfo, enumFieldsInner); EnumField[] array2 = enumFieldsInner; foreach (EnumField enumField in array2) { ImmutableDictionary <CultureInfo, string> .Builder builder3 = ImmutableDictionary.CreateBuilder <CultureInfo, string>(); builder3.Add(currentCulture, enumField.Description); builder2.Add(enumField.FieldInfo, ImmutableDictionary.ToImmutableDictionary <CultureInfo, string>(builder3)); } } EnumFiledCache = ImmutableDictionary.ToImmutableDictionary <Type, EnumField[]>(builder); FiledInfoCultureDescCache = ImmutableDictionary.ToImmutableDictionary <FieldInfo, ImmutableDictionary <CultureInfo, string> >(builder2); }
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 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(); }
static GatewayBucket() { GatewayBucket[] buckets = new[] { new GatewayBucket(GatewayBucketType.Unbucketed, BucketId.Create(null, "<gateway-unbucketed>", null), 120, 60), new GatewayBucket(GatewayBucketType.Identify, BucketId.Create(null, "<gateway-identify>", null), 1, 5), new GatewayBucket(GatewayBucketType.PresenceUpdate, BucketId.Create(null, "<gateway-presenceupdate>", null), 5, 60), }; ImmutableDictionary <GatewayBucketType, GatewayBucket> .Builder builder = ImmutableDictionary.CreateBuilder <GatewayBucketType, GatewayBucket>(); foreach (GatewayBucket bucket in buckets) { builder.Add(bucket.Type, bucket); } DefsByType = builder.ToImmutable(); ImmutableDictionary <BucketId, GatewayBucket> .Builder builder2 = ImmutableDictionary.CreateBuilder <BucketId, GatewayBucket>(); foreach (GatewayBucket bucket in buckets) { builder2.Add(bucket.Id, bucket); } DefsById = builder2.ToImmutable(); }
private static async Task <ImmutableDictionary <ProjectId, ImmutableArray <Diagnostic> > > GetAnalyzerDiagnosticsAsync(Solution solution, ImmutableArray <DiagnosticAnalyzer> analyzers, bool force, CancellationToken cancellationToken) { List <KeyValuePair <ProjectId, Task <ImmutableArray <Diagnostic> > > > projectDiagnosticTasks = new List <KeyValuePair <ProjectId, Task <ImmutableArray <Diagnostic> > > >(); // Make sure we analyze the projects in parallel foreach (var project in solution.Projects) { if (project.Language != LanguageNames.CSharp) { continue; } projectDiagnosticTasks.Add(new KeyValuePair <ProjectId, Task <ImmutableArray <Diagnostic> > >(project.Id, GetProjectAnalyzerDiagnosticsAsync(analyzers, project, force, cancellationToken))); } ImmutableDictionary <ProjectId, ImmutableArray <Diagnostic> > .Builder projectDiagnosticBuilder = ImmutableDictionary.CreateBuilder <ProjectId, ImmutableArray <Diagnostic> >(); foreach (var task in projectDiagnosticTasks) { projectDiagnosticBuilder.Add(task.Key, await task.Value.ConfigureAwait(false)); } return(projectDiagnosticBuilder.ToImmutable()); }
public static CompletionItem Create( string displayText, Glyph?glyph = null, ImmutableArray <SymbolMarkupToken> description = default(ImmutableArray <SymbolMarkupToken>), string sortText = null, string filterText = null, bool showsWarningIcon = false, ImmutableDictionary <string, string> properties = null, ImmutableArray <string> tags = default(ImmutableArray <string>)) { tags = tags.NullToEmpty(); //if (glyph != null) //{ // // put glyph tags first // tags = GlyphTags.GetTags(glyph.Value).AddRange(tags); //} if (showsWarningIcon) { tags = tags.Add(WellKnownTags.Warning); } properties = properties ?? ImmutableDictionary <string, string> .Empty; if (!description.IsDefault && description.Length > 0) { properties = properties.Add("Description", EncodeDescription(description)); } return(CompletionItem.Create( displayText: displayText, filterText: filterText, sortText: sortText, properties: properties, glyph: glyph ?? Glyph.None, tags: tags)); }
public override IDependency BeforeRemove( string projectPath, ITargetFramework targetFramework, IDependency dependency, ImmutableDictionary <string, IDependency> .Builder worldBuilder, ImmutableHashSet <IDependency> .Builder topLevelBuilder, out bool filterAnyChanges) { filterAnyChanges = false; if (!dependency.TopLevel || !dependency.Resolved) { return(dependency); } if (dependency.Flags.Contains(DependencyTreeFlags.PackageNodeFlags)) { // find sdk with the same name and clean dependencyIDs var sdkModelId = dependency.Name; var sdkId = Dependency.GetID(targetFramework, SdkRuleHandler.ProviderTypeString, sdkModelId); if (worldBuilder.TryGetValue(sdkId, out IDependency sdk)) { filterAnyChanges = true; // clean up sdk when corresponding package is removing sdk = sdk.ToUnresolved( schemaName: SdkReference.SchemaName, dependencyIDs: ImmutableList <string> .Empty); worldBuilder.Remove(sdk.Id); worldBuilder.Add(sdk.Id, sdk); topLevelBuilder.Remove(sdk); topLevelBuilder.Add(sdk); } } return(dependency); }
static void TestDynamicTable() { long time = 0; Stopwatch watch = new Stopwatch(); Random r = new Random(); string fileContent = fileHeader; ImmutableDictionary <int, int> dynamicTable = ImmutableDictionary <int, int> .Empty; for (int i = 1; i <= 10; i++) { Console.WriteLine("Running dynamic table with " + i + " fields..."); for (int u = minUpdates; u <= updates; u *= 10) { int[] keys = new int[i]; for (int d = 0; d < i; d++) { keys[d] = r.Next(); dynamicTable = dynamicTable.Add(keys[d], r.Next(-100, 100)); } watch.Restart(); for (int j = 0; j < u; j++) { dynamicTable.Last(); } watch.Stop(); time += watch.ElapsedMilliseconds; fileContent += i + "," + u + "," + ((double)watch.ElapsedMilliseconds / updates) + "\n"; } Console.WriteLine("Done"); } if (!System.IO.Directory.Exists("Benchmark")) { System.IO.Directory.CreateDirectory("Benchmark"); } System.IO.File.WriteAllText("Benchmark\\benchmark_dynamic_table.csv", fileContent); }
private Task <IMongoCollection <TEntry> > GetCollectionAsync <TEntry>(bool isInTransaction, CancellationToken cancellation) { Task <IMongoCollection <TEntry> > result; if (_collections.TryGetValue(typeof(TEntry), out var entry)) { result = (Task <IMongoCollection <TEntry> >)entry; } else { lock (_collectionsLock) { if (_collections.TryGetValue(typeof(TEntry), out entry)) { result = (Task <IMongoCollection <TEntry> >)entry; } else { var lazy = new AsyncLazy <IMongoCollection <TEntry> >( CreateCollectionAsync <TEntry>, AsyncLazyFlags.ExecuteOnCallingThread | AsyncLazyFlags.RetryOnFailure); result = lazy.Task; _collections = _collections.Add(typeof(TEntry), result); } } } // Cannot create a collection while beeing in a transaction. if (isInTransaction && !result.IsCompleted) { return(Task.FromResult <IMongoCollection <TEntry> >(null)); } return(result); }
public static ImmutableDictionary <CaptureId, FlowCaptureKind> CreateLValueFlowCaptures(ControlFlowGraph cfg) { // This method identifies flow capture reference operations that are target of an assignment // and marks them as lvalue flow captures. // Control flow graph can also contain flow captures // that are r-value captures at some point and l-values captures at other point in // the flow graph. Specifically, for an ICoalesceOperation a flow capture acts // as both an r-value and l-value flow capture. ImmutableDictionary <CaptureId, FlowCaptureKind> .Builder lvalueFlowCaptureIdBuilder = null; var rvalueFlowCaptureIds = new HashSet <CaptureId> (); foreach (var flowCaptureReference in cfg.DescendantOperations <IFlowCaptureReferenceOperation> (OperationKind.FlowCaptureReference)) { if (flowCaptureReference.Parent is IAssignmentOperation assignment && assignment.Target == flowCaptureReference || flowCaptureReference.IsInLeftOfDeconstructionAssignment(out _)) { lvalueFlowCaptureIdBuilder ??= ImmutableDictionary.CreateBuilder <CaptureId, FlowCaptureKind> (); var captureKind = flowCaptureReference.Parent.IsAnyCompoundAssignment() || rvalueFlowCaptureIds.Contains(flowCaptureReference.Id) ? FlowCaptureKind.LValueAndRValueCapture : FlowCaptureKind.LValueCapture; lvalueFlowCaptureIdBuilder.Add(flowCaptureReference.Id, captureKind); }
public Tissue2D Create(int maxX, int maxY, float ratioHealthyCells, float ratioInfectedCells) { maxX = Math.Abs(maxX); maxY = Math.Abs(maxY); var totalCount = maxY * maxX; if (ratioHealthyCells + ratioInfectedCells > 1) { throw new InvalidOperationException("Cannot create more then 100% cells."); } int countHealthyCells = (int)Math.Floor(ratioHealthyCells * totalCount); int countInfectedCells = (int)Math.Floor(ratioInfectedCells * totalCount); var xList = _shuffler.Shuffle(Enumerable.Range(0, maxX)); var yList = _shuffler.Shuffle(Enumerable.Range(0, maxY)); var cells = new List <ICell>(); cells.AddRange(CreateHealthyCells(countHealthyCells)); cells.AddRange(CreateInfectedCells(countInfectedCells)); cells.AddRange(CreateEmptyPlaces(totalCount - countHealthyCells - countInfectedCells)); var cellList = _shuffler.Shuffle(cells); for (int y = 0; y < maxY; y++) { for (int x = 0; x < maxX; x++) { var currentCell = (y + 1) * (x + 1); _tissue = _tissue.Add( new Location(xList.ElementAt(x), yList.ElementAt(y)), cellList.ElementAt(currentCell - 1)); } } return(new Tissue2D(_tissue)); }
internal static DefinitionItem CreateMetadataDefinition( ImmutableArray <string> tags, ImmutableArray <TaggedText> displayParts, ImmutableArray <TaggedText> nameDisplayParts, Solution solution, ISymbol symbol, ImmutableDictionary <string, string> properties = null, bool displayIfNoReferences = true ) { properties ??= ImmutableDictionary <string, string> .Empty; var symbolKey = symbol.GetSymbolKey().ToString(); var projectId = solution.GetOriginatingProjectId(symbol); Contract.ThrowIfNull(projectId); properties = properties .Add(MetadataSymbolKey, symbolKey) .Add(MetadataSymbolOriginatingProjectIdGuid, projectId.Id.ToString()) .Add(MetadataSymbolOriginatingProjectIdDebugName, projectId.DebugName); var originationParts = GetOriginationParts(symbol); return(new DefaultDefinitionItem( tags, displayParts, nameDisplayParts, originationParts, sourceSpans: ImmutableArray <DocumentSpan> .Empty, properties: properties, displayableProperties: ImmutableDictionary <string, string> .Empty, displayIfNoReferences: displayIfNoReferences )); }
internal static DefinitionItem CreateMetadataDefinition( ImmutableArray <string> tags, ImmutableArray <TaggedText> displayParts, ImmutableArray <TaggedText> nameDisplayParts, Solution solution, ISymbol symbol, ImmutableDictionary <string, string> properties = null, bool displayIfNoReferences = true) { properties = properties ?? ImmutableDictionary <string, string> .Empty; var symbolKey = symbol.GetSymbolKey().ToString(); var assemblyIdentityDisplayName = symbol.ContainingAssembly?.Identity.GetDisplayName(); properties = properties.Add(MetadataSymbolKey, symbolKey) .Add(MetadataAssemblyIdentityDisplayName, assemblyIdentityDisplayName); var originationParts = GetOriginationParts(symbol); return(new DefaultDefinitionItem( tags, displayParts, nameDisplayParts, originationParts, sourceSpans: ImmutableArray <DocumentSpan> .Empty, properties: properties, displayIfNoReferences: displayIfNoReferences)); }
protected override void OnReceive(object message) { if (message is CreateOmnetNode create) { var actorRef = create.Node; var id = OmnetSimulation.Instance().CreateNodeAndId(); _idToRef = _idToRef.Add(id, actorRef); _refToId = _refToId.Add(actorRef, id); } else if (message is Subscribe subscribe) { if (!_subscribers.ContainsKey(subscribe.Topic)) { _subscribers = _subscribers.Add(subscribe.Topic, ImmutableList <IActorRef> .Empty); } _subscribers.SetItem(subscribe.Topic, _subscribers[subscribe.Topic].Add(subscribe.Subscriber)); } else if (message is Broadcast broadcast) { // There seems to be no way to use publish here... we need to implement pubsub manually. if (_subscribers.ContainsKey(broadcast.Message.GetType())) { var subs = _subscribers[broadcast.Message.GetType()]; BroadcastInOmnet(broadcast.Sender, broadcast.Message).ContinueWith( result => { subs.ForEach(sub => sub.Tell(broadcast.Message, broadcast.Sender)); }); } } else if (message is Send send) { SendInOmnet(send.Sender, send.Receiver, send.Message) .ContinueWith(result => { send.Receiver.Tell(send.Message, send.Sender); }); } }
static SortingConfiguration() { ImmutableDictionary <string, SyntaxKind> .Builder kindConfigMappingBuilder = ImmutableDictionary.CreateBuilder <string, SyntaxKind>(); kindConfigMappingBuilder.Add("enum", SyntaxKind.EnumDeclaration); kindConfigMappingBuilder.Add("delegate", SyntaxKind.DelegateDeclaration); kindConfigMappingBuilder.Add("field", SyntaxKind.FieldDeclaration); kindConfigMappingBuilder.Add("event", SyntaxKind.EventDeclaration); // Events declared as fields kindConfigMappingBuilder.Add("eventField", SyntaxKind.EventFieldDeclaration); // Events declared using the property-like syntax (with add and remove blocks) kindConfigMappingBuilder.Add("constructor", SyntaxKind.ConstructorDeclaration); kindConfigMappingBuilder.Add("destructor", SyntaxKind.DestructorDeclaration); kindConfigMappingBuilder.Add("indexer", SyntaxKind.IndexerDeclaration); kindConfigMappingBuilder.Add("property", SyntaxKind.PropertyDeclaration); kindConfigMappingBuilder.Add("operator", SyntaxKind.OperatorDeclaration); kindConfigMappingBuilder.Add("implicitexplicit", SyntaxKind.ConversionOperatorDeclaration); kindConfigMappingBuilder.Add("method", SyntaxKind.MethodDeclaration); kindConfigMappingBuilder.Add("struct", SyntaxKind.StructDeclaration); kindConfigMappingBuilder.Add("class", SyntaxKind.ClassDeclaration); kindConfigMappingBuilder.Add("interface", SyntaxKind.InterfaceDeclaration); kindSortOrderConfigurationMapping = kindConfigMappingBuilder.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase); ImmutableDictionary <string, AccessModifier> .Builder accessModifierConfigMappingBuilder = ImmutableDictionary.CreateBuilder <string, AccessModifier>(); accessModifierConfigMappingBuilder.Add("public", AccessModifier.Public); accessModifierConfigMappingBuilder.Add("internal", AccessModifier.Internal); accessModifierConfigMappingBuilder.Add("protected", AccessModifier.Protected); accessModifierConfigMappingBuilder.Add("protectedinternal", AccessModifier.ProtectedInternal); accessModifierConfigMappingBuilder.Add("private", AccessModifier.Private); accessModifierConfigMappingBuilder.Add("privateprotected", AccessModifier.PrivateProtected); accessModifierConfigurationMapping = accessModifierConfigMappingBuilder.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase); ImmutableDictionary <string, Sorter> .Builder modifiersConfigMappingBuilder = ImmutableDictionary.CreateBuilder <string, Sorter>(); modifiersConfigMappingBuilder.Add("kind", Sorter.Kind); modifiersConfigMappingBuilder.Add("extern", Sorter.Extern); modifiersConfigMappingBuilder.Add("const", Sorter.Const); modifiersConfigMappingBuilder.Add("readonly", Sorter.Readonly); modifiersConfigMappingBuilder.Add("static", Sorter.Static); modifiersConfigMappingBuilder.Add("accessibility", Sorter.Accessibility); modifiersConfigMappingBuilder.Add("name", Sorter.Name); modifiersConfigMappingBuilder.Add("numberofmethodargs", Sorter.MethodArguments); modifiersConfigurationMapping = modifiersConfigMappingBuilder.ToImmutableDictionary(StringComparer.OrdinalIgnoreCase); }
private void Register(ImmutableDictionary <RecvOp, IPacketHandler <T> > .Builder builder, IPacketHandler <T> packetHandler) { builder.Add(packetHandler.OpCode, packetHandler); }
private Utf8String ComputeMangledMethodName(MethodDesc method) { string prependTypeName = null; if (!_mangleForCplusPlus) { prependTypeName = GetMangledTypeName(method.OwningType); } if (method is EcmaMethod) { var deduplicator = new HashSet <string>(); // Add consistent names for all methods of the type, independent on the order in which // they are compiled lock (this) { foreach (var m in method.OwningType.GetMethods()) { string name = SanitizeName(m.Name); name = DisambiguateName(name, deduplicator); deduplicator.Add(name); if (prependTypeName != null) { name = prependTypeName + "__" + name; } _mangledMethodNames = _mangledMethodNames.Add(m, name); } } return(_mangledMethodNames[method]); } string mangledName; var methodDefinition = method.GetTypicalMethodDefinition(); if (methodDefinition != method) { mangledName = GetMangledMethodName(methodDefinition.GetMethodDefinition()).ToString(); var inst = method.Instantiation; string mangledInstantiation = ""; for (int i = 0; i < inst.Length; i++) { string instArgName = GetMangledTypeName(inst[i]); if (_mangleForCplusPlus) { instArgName = instArgName.Replace("::", "_"); } if (i > 0) { mangledInstantiation += "__"; } mangledInstantiation += instArgName; } mangledName += NestMangledName(mangledInstantiation); } else { // Assume that Name is unique for all other methods mangledName = SanitizeName(method.Name); } if (prependTypeName != null) { mangledName = prependTypeName + "__" + mangledName; } Utf8String utf8MangledName = new Utf8String(mangledName); lock (this) { _mangledMethodNames = _mangledMethodNames.Add(method, utf8MangledName); } return(utf8MangledName); }
/// <summary> /// Adds a new, or replaces an existing dependency (keyed on <see cref="IDependency.Id"/>). /// </summary> /// <remarks> /// In the course of filtering one dependency, the filter may wish to modify or add other /// dependencies in the project's tree. This method allows that to happen. /// </remarks> public void AddOrUpdate(IDependency dependency) { _worldBuilder.Remove(dependency.Id); _worldBuilder.Add(dependency.Id, dependency); Changed = true; }
public ImmutableDictionary <string, object> Load(string applicantId, string key, ImmutableDictionary <string, object> input) { return(input.Add(Variables.CreditScore, CalculateCreditScore((int)input[Variables.CreditA], (int)input[Variables.CreditB], (Address)input[Variables.Address]))); }
protected void ContainsValueTestHelper <TKey, TValue>(ImmutableDictionary <TKey, TValue> map, TKey key, TValue value) { Assert.False(map.ContainsValue(value)); Assert.True(map.Add(key, value).ContainsValue(value)); }
private Utf8String ComputeUnqualifiedMangledMethodName(MethodDesc method) { if (method is EcmaMethod) { var deduplicator = new HashSet <string>(); // Add consistent names for all methods of the type, independent on the order in which // they are compiled lock (this) { if (!_unqualifiedMangledMethodNames.ContainsKey(method)) { foreach (var m in method.OwningType.GetMethods()) { string name = SanitizeName(m.Name); name = DisambiguateName(name, deduplicator); deduplicator.Add(name); _unqualifiedMangledMethodNames = _unqualifiedMangledMethodNames.Add(m, name); } } } return(_unqualifiedMangledMethodNames[method]); } Utf8String utf8MangledName; var methodDefinition = method.GetMethodDefinition(); if (methodDefinition != method) { // Instantiated generic method Utf8StringBuilder sb = new Utf8StringBuilder(); sb.Append(GetUnqualifiedMangledMethodName(methodDefinition.GetTypicalMethodDefinition())); sb.Append(EnterNameScopeSequence); var inst = method.Instantiation; for (int i = 0; i < inst.Length; i++) { string instArgName = GetMangledTypeName(inst[i]); if (_mangleForCplusPlus) { instArgName = instArgName.Replace("::", "_"); } if (i > 0) { sb.Append("__"); } sb.Append(instArgName); } sb.Append(ExitNameScopeSequence); utf8MangledName = sb.ToUtf8String(); } else { var typicalMethodDefinition = method.GetTypicalMethodDefinition(); if (typicalMethodDefinition != method) { // Method on an instantiated type utf8MangledName = GetUnqualifiedMangledMethodName(typicalMethodDefinition); } else if (method is IPrefixMangledMethod) { utf8MangledName = GetPrefixMangledMethodName((IPrefixMangledMethod)method); } else if (method is IPrefixMangledType) { utf8MangledName = GetPrefixMangledTypeName((IPrefixMangledType)method); } else if (method is IPrefixMangledSignature) { utf8MangledName = GetPrefixMangledSignatureName((IPrefixMangledSignature)method); } else { // Assume that Name is unique for all other methods utf8MangledName = new Utf8String(SanitizeName(method.Name)); } } // Unless we're doing CPP mangling, there's no point in caching the unqualified // method name. We only needed it to construct the fully qualified name. Nobody // is going to ask for the unqualified name again. if (_mangleForCplusPlus) { lock (this) { if (!_unqualifiedMangledMethodNames.ContainsKey(method)) { _unqualifiedMangledMethodNames = _unqualifiedMangledMethodNames.Add(method, utf8MangledName); } } } return(utf8MangledName); }
private async Task<ImmutableDictionary<DiagnosticAnalyzer, AnalysisResult>> MergeProjectDiagnosticAnalyzerDiagnosticsAsync( Project project, IEnumerable<StateSet> stateSets, Compilation compilationOpt, ImmutableDictionary<DiagnosticAnalyzer, AnalysisResult> result, CancellationToken cancellationToken) { // check whether there is IDE specific project diagnostic analyzer var ideAnalyzers = stateSets.Select(s => s.Analyzer).Where(a => a is ProjectDiagnosticAnalyzer || a is DocumentDiagnosticAnalyzer).ToImmutableArrayOrEmpty(); if (ideAnalyzers.Length <= 0) { return result; } // create result map var version = await GetDiagnosticVersionAsync(project, cancellationToken).ConfigureAwait(false); var builder = new CompilerDiagnosticExecutor.Builder(project, version); foreach (var analyzer in ideAnalyzers) { var documentAnalyzer = analyzer as DocumentDiagnosticAnalyzer; if (documentAnalyzer != null) { foreach (var document in project.Documents) { if (document.SupportsSyntaxTree) { var tree = await document.GetSyntaxTreeAsync(cancellationToken).ConfigureAwait(false); builder.AddSyntaxDiagnostics(tree, await ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, documentAnalyzer, AnalysisKind.Syntax, compilationOpt, cancellationToken).ConfigureAwait(false)); builder.AddSemanticDiagnostics(tree, await ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, documentAnalyzer, AnalysisKind.Semantic, compilationOpt, cancellationToken).ConfigureAwait(false)); } else { builder.AddExternalSyntaxDiagnostics(document.Id, await ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, documentAnalyzer, AnalysisKind.Syntax, compilationOpt, cancellationToken).ConfigureAwait(false)); builder.AddExternalSemanticDiagnostics(document.Id, await ComputeDocumentDiagnosticAnalyzerDiagnosticsAsync(document, documentAnalyzer, AnalysisKind.Semantic, compilationOpt, cancellationToken).ConfigureAwait(false)); } } } var projectAnalyzer = analyzer as ProjectDiagnosticAnalyzer; if (projectAnalyzer != null) { builder.AddCompilationDiagnostics(await ComputeProjectDiagnosticAnalyzerDiagnosticsAsync(project, projectAnalyzer, compilationOpt, cancellationToken).ConfigureAwait(false)); } // merge the result to existing one. result = result.Add(analyzer, builder.ToResult()); } return result; }
private static void AddDiagnosticForSymbolIfNeeded(ISymbol targetSymbol, Diagnostic diagnostic, ImmutableDictionary<ISymbol, List<Diagnostic>>.Builder diagnosticsMapBuilder) { if (diagnostic.IsSuppressed) { return; } if (!diagnosticsMapBuilder.TryGetValue(targetSymbol, out var diagnosticsForSymbol)) { diagnosticsForSymbol = new List<Diagnostic>(); diagnosticsMapBuilder.Add(targetSymbol, diagnosticsForSymbol); } diagnosticsForSymbol.Add(diagnostic); }
private static MSBuildWorkspace CreateWorkspace(ImmutableDictionary<string, string> propertiesOpt = null) { propertiesOpt = propertiesOpt ?? ImmutableDictionary<string, string>.Empty; // Explicitly add "CheckForSystemRuntimeDependency = true" property to correctly resolve facade references. // See https://github.com/dotnet/roslyn/issues/560 propertiesOpt = propertiesOpt.Add("CheckForSystemRuntimeDependency", "true"); propertiesOpt = propertiesOpt.Add("VisualStudioVersion", "14.0"); var w = MSBuildWorkspace.Create(properties: propertiesOpt, hostServices: WorkspaceHacks.Pack); w.LoadMetadataForReferencedProjects = true; return w; }
private ImmutableDictionary<string, string> AddSolutionProperties(ImmutableDictionary<string, string> properties, string solutionFilePath) { // http://referencesource.microsoft.com/#MSBuildFiles/C/ProgramFiles(x86)/MSBuild/14.0/bin_/amd64/Microsoft.Common.CurrentVersion.targets,296 properties = properties ?? ImmutableDictionary<string, string>.Empty; properties = properties.Add("SolutionName", Path.GetFileNameWithoutExtension(solutionFilePath)); properties = properties.Add("SolutionFileName", Path.GetFileName(solutionFilePath)); properties = properties.Add("SolutionPath", solutionFilePath); properties = properties.Add("SolutionDir", Path.GetDirectoryName(solutionFilePath)); properties = properties.Add("SolutionExt", Path.GetExtension(solutionFilePath)); return properties; }
private static MSBuildWorkspace CreateWorkspace(ImmutableDictionary<string, string> propertiesOpt = null) { propertiesOpt = propertiesOpt ?? ImmutableDictionary<string, string>.Empty; // Explicitly add "CheckForSystemRuntimeDependency = true" property to correctly resolve facade references. // See https://github.com/dotnet/roslyn/issues/560 propertiesOpt = propertiesOpt.Add("CheckForSystemRuntimeDependency", "true"); propertiesOpt = propertiesOpt.Add("VisualStudioVersion", "14.0"); try { Microsoft.CodeAnalysis.Host.HostServices hostServices = WorkspaceHacks.Pack; return MSBuildWorkspace.Create(properties: propertiesOpt, hostServices: hostServices); } catch {} return MSBuildWorkspace.Create(properties: propertiesOpt); }
public void Remove_Test() { Dictionary<int, string> _dictionary = new Dictionary<int, string> { {1, "aabb"}, {2, "bbcc"}, {3, "ccdd"} }; ImmutableDictionary<int, string> _immutableDictionary = new ImmutableDictionary<int, string>(_dictionary); _immutableDictionary.Add(new KeyValuePair<int, string>(4, "ddee")); }
public void Bind(TypeVariable variable, Type type) { Map = Map.Add(variable, type); }
/// <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 assemblyName = ((EcmaAssembly)ecmaType.EcmaModule).GetName().Name; bool isSystemPrivate = assemblyName.StartsWith("System.Private."); // Abbreviate System.Private to S.P. This might conflict with user defined assembly names, // but we already have a problem due to running SanitizeName without disambiguating the result // This problem needs a better fix. if (isSystemPrivate && !_mangleForCplusPlus) { assemblyName = "S.P." + assemblyName.Substring(15); } string prependAssemblyName = SanitizeName(assemblyName); 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) { bool isSystemModule = ecmaType.Module == ecmaType.Context.SystemModule; if (!_mangledTypeNames.ContainsKey(type)) { foreach (MetadataType t in ecmaType.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); if (_mangleForCplusPlus) { // Always generate a fully qualified name name = "::" + prependAssemblyName + "::" + name; } else { name = prependAssemblyName + "_" + name; // If this is one of the well known types, use a shorter name // We know this won't conflict because all the other types are // prefixed by the assembly name. if (isSystemModule) { switch (t.Category) { case TypeFlags.Boolean: name = "Bool"; break; case TypeFlags.Byte: name = "UInt8"; break; case TypeFlags.SByte: name = "Int8"; break; case TypeFlags.UInt16: name = "UInt16"; break; case TypeFlags.Int16: name = "Int16"; break; case TypeFlags.UInt32: name = "UInt32"; break; case TypeFlags.Int32: name = "Int32"; break; case TypeFlags.UInt64: name = "UInt64"; break; case TypeFlags.Int64: name = "Int64"; break; case TypeFlags.Char: name = "Char"; break; case TypeFlags.Double: name = "Double"; break; case TypeFlags.Single: name = "Single"; break; case TypeFlags.IntPtr: name = "IntPtr"; break; case TypeFlags.UIntPtr: name = "UIntPtr"; break; default: if (t.IsObject) { name = "Object"; } else if (t.IsString) { name = "String"; } break; } } } // 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: mangledName = "__MDArray" + EnterNameScopeSequence + GetMangledTypeName(((ArrayType)type).ElementType) + DelimitNameScopeSequence + ((ArrayType)type).Rank.ToStringInvariant() + ExitNameScopeSequence; break; case TypeFlags.SzArray: mangledName = "__Array" + NestMangledName(GetMangledTypeName(((ArrayType)type).ElementType)); 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 (_mangleForCplusPlus) { instArgName = instArgName.Replace("::", "_"); } if (i > 0) { mangledInstantiation += "__"; } mangledInstantiation += instArgName; } mangledName += NestMangledName(mangledInstantiation); } else if (type is IPrefixMangledMethod) { mangledName = GetPrefixMangledMethodName((IPrefixMangledMethod)type).ToString(); } else if (type is IPrefixMangledType) { mangledName = GetPrefixMangledTypeName((IPrefixMangledType)type).ToString(); } else { // This is a type definition. Since we didn't fall in the `is EcmaType` case above, // it's likely a compiler-generated type. mangledName = SanitizeName(((DefType)type).GetFullName(), true); // Always generate a fully qualified name if (_mangleForCplusPlus) { mangledName = "::" + mangledName; } } 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 static void AddStringFormatMap(ImmutableDictionary<IMethodSymbol, Info>.Builder builder, INamedTypeSymbol type, string methodName) { if (type == null) { return; } foreach (IMethodSymbol method in type.GetMembers(methodName).OfType<IMethodSymbol>()) { int formatIndex = FindParameterIndexOfName(method.Parameters, Format); if (formatIndex < 0 || formatIndex == method.Parameters.Length - 1) { // no valid format string continue; } int expectedArguments = GetExpectedNumberOfArguments(method.Parameters, formatIndex); builder.Add(method, new Info(formatIndex, expectedArguments)); } }
public static Imports FromSyntax( CSharpSyntaxNode declarationSyntax, InContainerBinder binder, ConsList <Symbol> basesBeingResolved, bool inUsing) { SyntaxList <UsingDirectiveSyntax> usingDirectives; SyntaxList <ExternAliasDirectiveSyntax> externAliasDirectives; if (declarationSyntax.Kind() == SyntaxKind.CompilationUnit) { var compilationUnit = (CompilationUnitSyntax)declarationSyntax; // using directives are not in scope within using directives usingDirectives = inUsing ? default(SyntaxList <UsingDirectiveSyntax>) : compilationUnit.Usings; externAliasDirectives = compilationUnit.Externs; } else if (declarationSyntax.Kind() == SyntaxKind.NamespaceDeclaration) { var namespaceDecl = (NamespaceDeclarationSyntax)declarationSyntax; // using directives are not in scope within using directives usingDirectives = inUsing ? default(SyntaxList <UsingDirectiveSyntax>) : namespaceDecl.Usings; externAliasDirectives = namespaceDecl.Externs; } else { return(Empty); } if (usingDirectives.Count == 0 && externAliasDirectives.Count == 0) { return(Empty); } // define all of the extern aliases first. They may used by the target of a using // using Bar=Goo::Bar; // using Goo::Baz; // extern alias Goo; var diagnostics = new DiagnosticBag(); var compilation = binder.Compilation; var externAliases = BuildExternAliases(externAliasDirectives, binder, diagnostics); var usings = ArrayBuilder <NamespaceOrTypeAndUsingDirective> .GetInstance(); ImmutableDictionary <string, AliasAndUsingDirective> .Builder usingAliases = null; if (usingDirectives.Count > 0) { // A binder that contains the extern aliases but not the usings. The resolution of the target of a using directive or alias // should not make use of other peer usings. Binder usingsBinder; if (declarationSyntax.SyntaxTree.Options.Kind != SourceCodeKind.Regular) { usingsBinder = compilation.GetBinderFactory(declarationSyntax.SyntaxTree).GetImportsBinder(declarationSyntax, inUsing: true); } else { var imports = externAliases.Length == 0 ? Empty : new Imports( compilation, ImmutableDictionary <string, AliasAndUsingDirective> .Empty, ImmutableArray <NamespaceOrTypeAndUsingDirective> .Empty, externAliases, diagnostics: null); usingsBinder = new InContainerBinder(binder.Container, binder.Next, imports); } var uniqueUsings = PooledHashSet <NamespaceOrTypeSymbol> .GetInstance(); foreach (var usingDirective in usingDirectives) { compilation.RecordImport(usingDirective); if (usingDirective.Alias != null) { if (usingDirective.Alias.Name.Identifier.ContextualKind() == SyntaxKind.GlobalKeyword) { diagnostics.Add(ErrorCode.WRN_GlobalAliasDefn, usingDirective.Alias.Name.Location); } if (usingDirective.StaticKeyword != default(SyntaxToken)) { diagnostics.Add(ErrorCode.ERR_NoAliasHere, usingDirective.Alias.Name.Location); } string identifierValueText = usingDirective.Alias.Name.Identifier.ValueText; if (usingAliases != null && usingAliases.ContainsKey(identifierValueText)) { // Suppress diagnostics if we're already broken. if (!usingDirective.Name.IsMissing) { // The using alias '{0}' appeared previously in this namespace diagnostics.Add(ErrorCode.ERR_DuplicateAlias, usingDirective.Alias.Name.Location, identifierValueText); } } else { // an O(m*n) algorithm here but n (number of extern aliases) will likely be very small. foreach (var externAlias in externAliases) { if (externAlias.Alias.Name == identifierValueText) { // The using alias '{0}' appeared previously in this namespace diagnostics.Add(ErrorCode.ERR_DuplicateAlias, usingDirective.Location, identifierValueText); break; } } if (usingAliases == null) { usingAliases = ImmutableDictionary.CreateBuilder <string, AliasAndUsingDirective>(); } // construct the alias sym with the binder for which we are building imports. That // way the alias target can make use of extern alias definitions. usingAliases.Add(identifierValueText, new AliasAndUsingDirective(new AliasSymbol(usingsBinder, usingDirective), usingDirective)); } } else { if (usingDirective.Name.IsMissing) { //don't try to lookup namespaces inserted by parser error recovery continue; } var declarationBinder = usingsBinder.WithAdditionalFlags(BinderFlags.SuppressConstraintChecks); var imported = declarationBinder.BindNamespaceOrTypeSymbol(usingDirective.Name, diagnostics, basesBeingResolved).NamespaceOrTypeSymbol; if (imported.Kind == SymbolKind.Namespace) { if (usingDirective.StaticKeyword != default(SyntaxToken)) { diagnostics.Add(ErrorCode.ERR_BadUsingType, usingDirective.Name.Location, imported); } else if (uniqueUsings.Contains(imported)) { diagnostics.Add(ErrorCode.WRN_DuplicateUsing, usingDirective.Name.Location, imported); } else { uniqueUsings.Add(imported); usings.Add(new NamespaceOrTypeAndUsingDirective(imported, usingDirective)); } } else if (imported.Kind == SymbolKind.NamedType) { if (usingDirective.StaticKeyword == default(SyntaxToken)) { diagnostics.Add(ErrorCode.ERR_BadUsingNamespace, usingDirective.Name.Location, imported); } else { var importedType = (NamedTypeSymbol)imported; if (uniqueUsings.Contains(importedType)) { diagnostics.Add(ErrorCode.WRN_DuplicateUsing, usingDirective.Name.Location, importedType); } else { declarationBinder.ReportDiagnosticsIfObsolete(diagnostics, importedType, usingDirective.Name, hasBaseReceiver: false); uniqueUsings.Add(importedType); usings.Add(new NamespaceOrTypeAndUsingDirective(importedType, usingDirective)); } } } else if (imported.Kind != SymbolKind.ErrorType) { // Do not report additional error if the symbol itself is erroneous. // error: '<symbol>' is a '<symbol kind>' but is used as 'type or namespace' diagnostics.Add(ErrorCode.ERR_BadSKknown, usingDirective.Name.Location, usingDirective.Name, imported.GetKindText(), MessageID.IDS_SK_TYPE_OR_NAMESPACE.Localize()); } } } uniqueUsings.Free(); } if (diagnostics.IsEmptyWithoutResolution) { diagnostics = null; } return(new Imports(compilation, usingAliases.ToImmutableDictionaryOrEmpty(), usings.ToImmutableAndFree(), externAliases, diagnostics)); }
private static bool TryAddImport( string alias, NamespaceOrTypeSymbol targetSymbol, ArrayBuilder<NamespaceOrTypeAndUsingDirective> usingsBuilder, ImmutableDictionary<string, AliasAndUsingDirective>.Builder usingAliases, InContainerBinder binder, ImportRecord importRecord) { if (alias == null) { usingsBuilder.Add(new NamespaceOrTypeAndUsingDirective(targetSymbol, usingDirective: null)); } else { IdentifierNameSyntax aliasSyntax; if (!TryParseIdentifierNameSyntax(alias, out aliasSyntax)) { Debug.WriteLine($"Import record '{importRecord}' has syntactically invalid alias '{alias}'"); return false; } var aliasSymbol = AliasSymbol.CreateCustomDebugInfoAlias(targetSymbol, aliasSyntax.Identifier, binder); usingAliases.Add(alias, new AliasAndUsingDirective(aliasSymbol, usingDirective: null)); } return true; }
public IBidirectionalMap <TKey, TValue> Add(TKey key, TValue value) { return(new BidirectionalMap <TKey, TValue>( _forwardMap.Add(key, value), _backwardMap.Add(value, key))); }
/// <summary> /// Adds a key-value pair to the object being built. /// </summary> /// <param name="key">the key to add</param> /// <param name="value">the value to add</param> /// <returns>the same builder</returns> public ObjectBuilder Add(string key, LdValue value) { _builder.Add(key, value); return(this); }
/// <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); }
public Task <(string?id, object state)> NewStorageAccount(MockResourceArgs args, ImmutableDictionary <string, object> .Builder outputs) { outputs.Add("name", args.Inputs["accountName"]); return(Task.FromResult((args.Id, (object)outputs))); }