// internal for testing
        internal static IReadOnlyDictionary <AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
        {
            var result = new Dictionary <AnonymousTypeKey, AnonymousTypeValue>();

            foreach (var handle in reader.TypeDefinitions)
            {
                var def = reader.GetTypeDefinition(handle);
                if (!def.Namespace.IsNil)
                {
                    continue;
                }
                if (!reader.StringComparer.StartsWith(def.Name, GeneratedNames.AnonymousNamePrefix))
                {
                    continue;
                }
                var   metadataName = reader.GetString(def.Name);
                short arity;
                var   name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out arity);
                int   index;
                if (GeneratedNames.TryParseAnonymousTypeTemplateName(name, out index))
                {
                    var builder = ArrayBuilder <AnonymousTypeKeyField> .GetInstance();

                    if (TryGetAnonymousTypeKey(reader, def, builder))
                    {
                        var type  = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
                        var key   = new AnonymousTypeKey(builder.ToImmutable());
                        var value = new AnonymousTypeValue(name, index, type.GetCciAdapter());
                        result.Add(key, value);
                    }
                    builder.Free();
                }
            }
            return(result);
        }
 private static IReadOnlyDictionary<AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMap(
     MetadataReader reader,
     Symbols.Metadata.PE.MetadataDecoder metadataDecoder)
 {
     var result = new Dictionary<AnonymousTypeKey, AnonymousTypeValue>();
     foreach (var handle in reader.TypeDefinitions)
     {
         var def = reader.GetTypeDefinition(handle);
         if (!def.Namespace.IsNil)
         {
             continue;
         }
         if (!reader.StringStartsWith(def.Name, GeneratedNames.AnonymousNamePrefix))
         {
             continue;
         }
         var metadataName = reader.GetString(def.Name);
         short arity;
         var name = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out arity);
         int index;
         if (GeneratedNames.TryParseAnonymousTypeTemplateName(name, out index))
         {
             var builder = ArrayBuilder<string>.GetInstance();
             if (TryGetAnonymousTypeKey(reader, def, builder))
             {
                 var type = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
                 var key = new AnonymousTypeKey(builder.ToImmutable());
                 var value = new AnonymousTypeValue(name, index, type);
                 result.Add(key, value);
             }
             builder.Free();
         }
     }
     return result;
 }
            internal bool TryFindAnonymousType(NamedTypeSymbol type, out AnonymousTypeValue otherType)
            {
                Debug.Assert((object)type.ContainingSymbol == (object)this.sourceAssembly.GlobalNamespace);
                Debug.Assert(AnonymousTypeManager.IsAnonymousTypeTemplate(type));

                var key = new AnonymousTypeKey(AnonymousTypeManager.GetTemplatePropertyNames(type));
                return this.anonymousTypeMap.TryGetValue(key, out otherType);
            }
        // internal for testing
        internal static IReadOnlyDictionary <AnonymousTypeKey, AnonymousTypeValue> GetAnonymousTypeMapFromMetadata(MetadataReader reader, MetadataDecoder metadataDecoder)
        {
            // In general, the anonymous type name is "<{module-id}>f__AnonymousType{index}#{submission-index}",
            // but EnC is not supported for modules nor submissions. Hence we only look for type names with no module id and no submission index.
            const string AnonymousNameWithoutModulePrefix = "<>f__AnonymousType";

            var result = new Dictionary <AnonymousTypeKey, AnonymousTypeValue>();

            foreach (var handle in reader.TypeDefinitions)
            {
                var def = reader.GetTypeDefinition(handle);
                if (!def.Namespace.IsNil)
                {
                    continue;
                }

                if (!reader.StringComparer.StartsWith(def.Name, AnonymousNameWithoutModulePrefix))
                {
                    continue;
                }

                var metadataName = reader.GetString(def.Name);
                var name         = MetadataHelpers.InferTypeArityAndUnmangleMetadataName(metadataName, out _);

                if (name.StartsWith(AnonymousNameWithoutModulePrefix, StringComparison.Ordinal) &&
                    int.TryParse(name.Substring(AnonymousNameWithoutModulePrefix.Length), NumberStyles.None, CultureInfo.InvariantCulture, out int index))
                {
                    var builder = ArrayBuilder <AnonymousTypeKeyField> .GetInstance();

                    if (TryGetAnonymousTypeKey(reader, def, builder))
                    {
                        var type  = (NamedTypeSymbol)metadataDecoder.GetTypeOfToken(handle);
                        var key   = new AnonymousTypeKey(builder.ToImmutable());
                        var value = new AnonymousTypeValue(name, index, type.GetCciAdapter());
                        result.Add(key, value);
                    }

                    builder.Free();
                }
            }

            return(result);
        }