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; }
/// <summary>Gets the name of an attribute.</summary> /// <param name="reader">The metadata reader.</param> /// <param name="attr">The attribute.</param> /// <param name="typeNamespaceHandle">The namespace of the attribute.</param> /// <param name="typeNameHandle">The name of the attribute.</param> /// <returns>true if the name could be retrieved; otherwise, false.</returns> private static bool TryGetAttributeName(MetadataReader reader, CustomAttribute attr, out StringHandle typeNamespaceHandle, out StringHandle typeNameHandle) { EntityHandle ctorHandle = attr.Constructor; switch (ctorHandle.Kind) { case HandleKind.MemberReference: EntityHandle container = reader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent; if (container.Kind == HandleKind.TypeReference) { TypeReference tr = reader.GetTypeReference((TypeReferenceHandle)container); typeNamespaceHandle = tr.Namespace; typeNameHandle = tr.Name; return true; } break; case HandleKind.MethodDefinition: MethodDefinition md = reader.GetMethodDefinition((MethodDefinitionHandle)ctorHandle); TypeDefinition td = reader.GetTypeDefinition(md.GetDeclaringType()); typeNamespaceHandle = td.Namespace; typeNameHandle = td.Name; return true; } // Unusual case, potentially invalid IL typeNamespaceHandle = default(StringHandle); typeNameHandle = default(StringHandle); return false; }
private static string GetFullName(MetadataReader reader, TypeDefinition type) { var typeName = reader.GetString(type.Name); if (TypeAttributes.NestedPublic == (type.Attributes & TypeAttributes.NestedPublic)) { // Need to take into account the containing type. var declaringType = reader.GetTypeDefinition(type.GetDeclaringType()); var declaringTypeFullName = GetFullName(reader, declaringType); return $"{declaringTypeFullName}+{typeName}"; } var namespaceName = reader.GetString(type.Namespace); if (string.IsNullOrEmpty(namespaceName)) { return typeName; } return $"{namespaceName}.{typeName}"; }
private static List<TypeInfo> GetTypeInfoList(MetadataReader reader) { var list = new List<TypeInfo>(); foreach (var handle in reader.TypeDefinitions) { var type = reader.GetTypeDefinition(handle); if (!IsValidIdentifier(reader, type.Name)) { continue; } var methodCount = GetMethodCount(reader, type); if (!ShouldIncludeType(reader, type, methodCount)) { continue; } var fullName = GetFullName(reader, type); list.Add(new TypeInfo(fullName, methodCount)); } // Ensure we get classes back in a deterministic order. list.Sort((x, y) => x.FullName.CompareTo(y.FullName)); return list; }
internal static IEnumerable<string> GetFullTypeNames(MetadataReader metadataReader) { foreach (var typeDefHandle in metadataReader.TypeDefinitions) { var typeDef = metadataReader.GetTypeDefinition(typeDefHandle); var ns = metadataReader.GetString(typeDef.Namespace); var name = metadataReader.GetString(typeDef.Name); yield return (ns.Length == 0) ? name : (ns + "." + name); } }
private static TypeHandle GetTokenForType(MetadataReader metadataReader, string typeName) { Assert.NotNull(typeName); Assert.NotEmpty(typeName); foreach (var typeDef in metadataReader.TypeDefinitions) { string name = metadataReader.GetString(metadataReader.GetTypeDefinition(typeDef).Name); if (typeName.Equals(name)) { return typeDef; } } AssertEx.Fail("Unable to find type:" + typeName); return default(TypeHandle); }
private static void LookupMetadataDefinitions( MetadataReader reader, NamespaceDefinition namespaceDefinition, OrderPreservingMultiDictionary<string, MetadataDefinition> definitionMap) { foreach (var child in namespaceDefinition.NamespaceDefinitions) { var definition = MetadataDefinition.Create(reader, child); definitionMap.Add(definition.Name, definition); } foreach (var child in namespaceDefinition.TypeDefinitions) { var typeDefinition = reader.GetTypeDefinition(child); if (IsPublic(typeDefinition.Attributes)) { var definition = MetadataDefinition.Create(reader, typeDefinition); definitionMap.Add(definition.Name, definition); } } }
private static void GetAttributeParentNameAndKind(MetadataReader metadataReader, Handle token, out string name, out SymbolKind kind) { switch (token.HandleType) { case HandleType.Assembly: name = null; kind = SymbolKind.Assembly; return; case HandleType.Type: name = metadataReader.GetString(metadataReader.GetTypeDefinition((TypeHandle)token).Name); kind = SymbolKind.NamedType; return; case HandleType.Method: name = metadataReader.GetString(metadataReader.GetMethod((MethodHandle)token).Name); kind = SymbolKind.Method; return; default: throw TestExceptionUtilities.UnexpectedValue(token.HandleType); } }
private static string GetFullTypeName(MetadataReader metadataReader, Handle handle) { if (handle.IsNil) { return null; } if (handle.HandleType == HandleType.Type) { var type = metadataReader.GetTypeDefinition((TypeHandle)handle); string name = metadataReader.GetString(type.Name); while (IsNested(type.Attributes)) { var enclosingType = metadataReader.GetTypeDefinition(type.GetDeclaringType()); name = metadataReader.GetString(enclosingType.Name) + "+" + name; type = enclosingType; } if (type.Namespace.IsNil) { return name; } return metadataReader.GetString(type.Namespace) + "." + name; } if (handle.HandleType == HandleType.TypeReference) { var typeRef = metadataReader.GetTypeReference((TypeReferenceHandle)handle); string name = metadataReader.GetString(typeRef.Name); if (typeRef.Namespace.IsNil) { return name; } return metadataReader.GetString(typeRef.Namespace) + "." + name; } return string.Format("<unexpected token kind: {0}>", AsToken(metadataReader.GetToken(handle))); }
private static void LookupMetadataDefinitions( MetadataReader reader, TypeDefinition typeDefinition, OrderPreservingMultiDictionary<string, MetadataDefinition> definitionMap) { // Only bother looking for extension methods in static types. if ((typeDefinition.Attributes & TypeAttributes.Abstract) != 0 && (typeDefinition.Attributes & TypeAttributes.Sealed) != 0) { foreach (var child in typeDefinition.GetMethods()) { var method = reader.GetMethodDefinition(child); if ((method.Attributes & MethodAttributes.SpecialName) != 0 || (method.Attributes & MethodAttributes.RTSpecialName) != 0) { continue; } // SymbolTreeInfo is only searched for types and extension methods. // So we don't want to pull in all methods here. As a simple approximation // we just pull in methods that have attributes on them. if ((method.Attributes & MethodAttributes.MemberAccessMask) == MethodAttributes.Public && (method.Attributes & MethodAttributes.Static) != 0 && method.GetCustomAttributes().Count > 0) { var definition = new MetadataDefinition( MetadataDefinitionKind.Member, reader.GetString(method.Name)); definitionMap.Add(definition.Name, definition); } } } foreach (var child in typeDefinition.GetNestedTypes()) { var type = reader.GetTypeDefinition(child); // We don't include internals from metadata assemblies. It's less likely that // a project would have IVT to it and so it helps us save on memory. It also // means we can avoid loading lots and lots of obfuscated code in the case the // dll was obfuscated. if (IsPublic(type.Attributes)) { var definition = MetadataDefinition.Create(reader, type); definitionMap.Add(definition.Name, definition); } } }
/// <summary> /// Get the full name of a Type. /// </summary> private static string GetTypeFullName(MetadataReader metadataReader, TypeDefinition typeDefinition) { string fullName; string typeName = metadataReader.GetString(typeDefinition.Name); string nsName = metadataReader.GetString(typeDefinition.Namespace); // Get the enclosing type if the type is nested TypeDefinitionHandle declaringTypeHandle = typeDefinition.GetDeclaringType(); if (declaringTypeHandle.IsNil) { fullName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", nsName, typeName); } else { fullName = typeName; while (!declaringTypeHandle.IsNil) { TypeDefinition declaringTypeDef = metadataReader.GetTypeDefinition(declaringTypeHandle); declaringTypeHandle = declaringTypeDef.GetDeclaringType(); if (declaringTypeHandle.IsNil) { fullName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}+{2}", metadataReader.GetString(declaringTypeDef.Namespace), metadataReader.GetString(declaringTypeDef.Name), fullName); } else { fullName = string.Format(CultureInfo.InvariantCulture, "{0}+{1}", metadataReader.GetString(declaringTypeDef.Name), fullName); } } } return fullName; }
private bool IsPubliclyVisible(MetadataReader referenceMetadata, MethodDefinition methodDefinition, bool checkDeclaringType = false) { switch (methodDefinition.Attributes & MethodAttributes.MemberAccessMask) { case MethodAttributes.Public: case MethodAttributes.Family: case MethodAttributes.FamORAssem: break; case MethodAttributes.FamANDAssem: case MethodAttributes.Assembly: case MethodAttributes.Private: case MethodAttributes.PrivateScope: default: return false; } if (checkDeclaringType) { TypeDefinition declaringTypeDefinition = referenceMetadata.GetTypeDefinition(methodDefinition.GetDeclaringType()); if (!IsPubliclyVisible(referenceMetadata, declaringTypeDefinition)) return false; } return true; }
private bool IsPubliclyVisible(MetadataReader metadataReader, TypeDefinition typeDefinition) { switch (typeDefinition.Attributes & TypeAttributes.VisibilityMask) { case TypeAttributes.Public: return true; case TypeAttributes.NestedPublic: case TypeAttributes.NestedFamORAssem: case TypeAttributes.NestedFamily: TypeDefinition declaringType = metadataReader.GetTypeDefinition(typeDefinition.GetDeclaringType()); return IsPubliclyVisible(metadataReader, declaringType); case TypeAttributes.NestedFamANDAssem: case TypeAttributes.NestedPrivate: case TypeAttributes.NotPublic: default: return false; } }
private string GetMetadataName(MetadataReader metadataReader, MethodDefinition methodDefinition) { TypeDefinition declaringTypeDefinition = metadataReader.GetTypeDefinition(methodDefinition.GetDeclaringType()); string typeName = GetMetadataName(metadataReader, declaringTypeDefinition); string methodName = metadataReader.GetString(methodDefinition.Name); return string.Format("{0}.{1}", typeName, methodName); }
private string GetMetadataName(MetadataReader metadataReader, TypeDefinition typeDefinition) { if (typeDefinition.GetDeclaringType().IsNil) { string namespaceName = metadataReader.GetString(typeDefinition.Namespace); string typeName = metadataReader.GetString(typeDefinition.Name); return string.Format("{0}.{1}", namespaceName, typeName); } else { TypeDefinition declaringTypeDefinition = metadataReader.GetTypeDefinition(typeDefinition.GetDeclaringType()); string declaringTypeName = GetMetadataName(metadataReader, declaringTypeDefinition); string name = metadataReader.GetString(typeDefinition.Name); return string.Format("{0}+{1}", declaringTypeName, name); } }