internal IMethod WrapAccessor(ref IMethod cachingField, IMethod accessorDefinition) { if (accessorDefinition == null) { return(null); } var result = LazyInit.VolatileRead(ref cachingField); if (result != null) { return(result); } else { return(LazyInit.GetOrSet(ref cachingField, new SpecializedMethod(accessorDefinition, substitution))); } }
/// <summary> /// Creates a type parameter reference. /// For common type parameter references, this method may return a shared instance. /// </summary> public static TypeParameterReference Create(SymbolKind ownerType, int index) { if (index >= 0 && index < 8 && (ownerType == SymbolKind.TypeDefinition || ownerType == SymbolKind.Method)) { TypeParameterReference[] arr = (ownerType == SymbolKind.TypeDefinition) ? classTypeParameterReferences : methodTypeParameterReferences; TypeParameterReference result = LazyInit.VolatileRead(ref arr[index]); if (result == null) { result = LazyInit.GetOrSet(ref arr[index], new TypeParameterReference(ownerType, index)); } return(result); } else { return(new TypeParameterReference(ownerType, index)); } }
Dictionary <FullNameAndTypeParameterCount, DefaultResolvedTypeDefinition> GetTypes() { var dict = this.typeDict; if (dict != null) { LazyInit.ReadBarrier(); return(dict); } else { var comparer = FullNameAndTypeParameterCountComparer.Ordinal; dict = projectContent.TopLevelTypeDefinitions .GroupBy(t => new FullNameAndTypeParameterCount(t.Namespace, t.Name, t.TypeParameters.Count), comparer) .ToDictionary(g => g.Key, g => new DefaultResolvedTypeDefinition(context, g.ToArray()), comparer); return(LazyInit.GetOrSet(ref this.typeDict, dict)); } }
private void DecodeSignature() { var methodDef = module.metadata.GetMethodDefinition(handle); var genericContext = new GenericContext(DeclaringType.TypeParameters, this.TypeParameters); IType returnType; IParameter[] parameters; try { var nullableContext = methodDef.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition.NullableContext; var signature = methodDef.DecodeSignature(module.TypeProvider, genericContext); (returnType, parameters) = DecodeSignature(module, this, signature, methodDef.GetParameters(), nullableContext); } catch (BadImageFormatException) { returnType = SpecialType.UnknownType; parameters = Empty <IParameter> .Array; } LazyInit.GetOrSet(ref this.returnType, returnType); LazyInit.GetOrSet(ref this.parameters, parameters); }
Dictionary <string, INamespace> GetChildNamespaces() { var result = LazyInit.VolatileRead(ref this.childNamespaces); if (result != null) { return(result); } else { result = new Dictionary <string, INamespace>(compilation.NameComparer); foreach (var g in namespaces.SelectMany(ns => ns.ChildNamespaces).GroupBy(ns => ns.Name, compilation.NameComparer)) { result.Add(g.Key, new MergedNamespace(this, g.ToArray())); } return(LazyInit.GetOrSet(ref this.childNamespaces, result)); } }
internal IMethod GetAccessor(ref IMethod accessorField, IUnresolvedMethod unresolvedAccessor) { if (unresolvedAccessor == null) { return(null); } IMethod result = accessorField; if (result != null) { LazyInit.ReadBarrier(); return(result); } else { return(LazyInit.GetOrSet(ref accessorField, (IMethod)unresolvedAccessor.CreateResolved(context))); } }
internal IMethod WrapAccessor(ref IMethod cachingField, IMethod accessorDefinition) { if (accessorDefinition == null) { return(null); } var result = LazyInit.VolatileRead(ref cachingField); if (result != null) { return(result); } else { var sm = accessorDefinition.Specialize(substitution); //sm.AccessorOwner = this; return(LazyInit.GetOrSet(ref cachingField, sm)); } }
Dictionary <FullNameAndTypeParameterCount, ITypeDefinition> GetTypes() { var dict = LazyInit.VolatileRead(ref this.typeDict); if (dict != null) { return(dict); } else { // Always use the ordinal comparer for the main dictionary so that partial classes // get merged correctly. // The compilation's comparer will be used for the per-namespace dictionaries. var comparer = FullNameAndTypeParameterCountComparer.Ordinal; dict = projectContent.TopLevelTypeDefinitions .GroupBy(t => new FullNameAndTypeParameterCount(t.Namespace, t.Name, t.TypeParameters.Count), comparer) .ToDictionary(g => g.Key, g => CreateResolvedTypeDefinition(g.ToArray()), comparer); return(LazyInit.GetOrSet(ref this.typeDict, dict)); } }
private IType DecodeTypeAndVolatileFlag() { var metadata = module.metadata; var fieldDef = metadata.GetFieldDefinition(handle); IType ty; try { ty = fieldDef.DecodeSignature(module.TypeProvider, new GenericContext(DeclaringType?.TypeParameters)); if (ty is ModifiedType mod && mod.Modifier.Name == "IsVolatile" && mod.Modifier.Namespace == "System.Runtime.CompilerServices") { Volatile.Write(ref this.isVolatile, true); ty = mod.ElementType; } ty = ApplyAttributeTypeVisitor.ApplyAttributesToType(ty, Compilation, fieldDef.GetCustomAttributes(), metadata, module.TypeSystemOptions); } catch (BadImageFormatException) { ty = SpecialType.UnknownType; } return(LazyInit.GetOrSet(ref this.type, ty)); }
public object GetConstantValue(bool throwOnInvalidMetadata) { object val = LazyInit.VolatileRead(ref this.constantValue); if (val != null) { return(val); } try { var metadata = module.metadata; var fieldDef = metadata.GetFieldDefinition(handle); if (IsDecimalConstant && DecimalConstantHelper.AllowsDecimalConstants(module)) { val = DecimalConstantHelper.GetDecimalConstantValue(module, fieldDef.GetCustomAttributes()); } else { var constantHandle = fieldDef.GetDefaultValue(); if (constantHandle.IsNil) { return(null); } var constant = metadata.GetConstant(constantHandle); var blobReader = metadata.GetBlobReader(constant.Value); try { val = blobReader.ReadConstant(constant.TypeCode); } catch (ArgumentOutOfRangeException) { throw new BadImageFormatException($"Constant with invalid typecode: {constant.TypeCode}"); } } return(LazyInit.GetOrSet(ref this.constantValue, val)); } catch (BadImageFormatException) when(!throwOnInvalidMetadata) { return(null); } }
internal IUnresolvedTypeDefinition GetTypeDefByToken(Mono.Cecil.MetadataToken token) { if (token.TokenType != Mono.Cecil.TokenType.TypeDef) { throw new ArgumentException("Token must be typedef-token."); } var lookup = LazyInit.VolatileRead(ref allTypesByMetadata); if (lookup == null) { lookup = LazyInit.GetOrSet(ref allTypesByMetadata, BuildMetadataLookup()); } if (token.RID < lookup.Length) { return(lookup[token.RID]); } else { return(null); } }
private void DecodeSignature() { var methodDef = module.metadata.GetMethodDefinition(handle); var genericContext = new GenericContext(DeclaringType.TypeParameters, this.TypeParameters); IType returnType; IParameter[] parameters; ModifiedType mod; try { var nullableContext = methodDef.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition.NullableContext; var signature = methodDef.DecodeSignature(module.TypeProvider, genericContext); (returnType, parameters, mod) = DecodeSignature(module, this, signature, methodDef.GetParameters(), nullableContext, module.OptionsForEntity(this)); } catch (BadImageFormatException) { returnType = SpecialType.UnknownType; parameters = Empty <IParameter> .Array; mod = null; } this.isInitOnly = mod is { Modifier : { Name : "IsExternalInit", Namespace : "System.Runtime.CompilerServices" } }; LazyInit.GetOrSet(ref this.returnType, returnType); LazyInit.GetOrSet(ref this.parameters, parameters); }
private void DecodeSignature() { var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle); var genericContext = new GenericContext(DeclaringType.TypeParameters); IType returnType; IParameter[] parameters; try { var signature = propertyDef.DecodeSignature(module.TypeProvider, genericContext); var accessors = propertyDef.GetAccessors(); ParameterHandleCollection?parameterHandles; Nullability nullableContext; if (!accessors.Getter.IsNil) { var getter = module.metadata.GetMethodDefinition(accessors.Getter); parameterHandles = getter.GetParameters(); nullableContext = getter.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious; } else if (!accessors.Setter.IsNil) { var setter = module.metadata.GetMethodDefinition(accessors.Setter); parameterHandles = setter.GetParameters(); nullableContext = setter.GetCustomAttributes().GetNullableContext(module.metadata) ?? DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious; } else { parameterHandles = null; nullableContext = DeclaringTypeDefinition?.NullableContext ?? Nullability.Oblivious; } (returnType, parameters) = MetadataMethod.DecodeSignature(module, this, signature, parameterHandles, nullableContext); } catch (BadImageFormatException) { returnType = SpecialType.UnknownType; parameters = Empty <IParameter> .Array; } LazyInit.GetOrSet(ref this.returnType, returnType); LazyInit.GetOrSet(ref this.parameters, parameters); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(MethodCore.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers); return(LazyInit.GetOrSet(ref this.memberList, result)); }
IList <IAttribute> GetAttributes(ref IList <IAttribute> field, bool assemblyAttributes) { IList <IAttribute> result = LazyInit.VolatileRead(ref field); if (result != null) { return(result); } else { result = new List <IAttribute>(); foreach (var unresolvedFile in projectContent.Files.OfType <CSharpUnresolvedFile>()) { var attributes = assemblyAttributes ? unresolvedFile.AssemblyAttributes : unresolvedFile.ModuleAttributes; var context = new CSharpTypeResolveContext(this, unresolvedFile.RootUsingScope.Resolve(compilation)); foreach (var unresolvedAttr in attributes) { result.Add(unresolvedAttr.CreateResolvedAttribute(context)); } } return(LazyInit.GetOrSet(ref field, result)); } }
private void DecodeSignature() { var propertyDef = module.metadata.GetPropertyDefinition(propertyHandle); var genericContext = new GenericContext(DeclaringType.TypeParameters); var signature = propertyDef.DecodeSignature(module.TypeProvider, genericContext); var accessors = propertyDef.GetAccessors(); ParameterHandleCollection?parameterHandles; if (!accessors.Getter.IsNil) { parameterHandles = module.metadata.GetMethodDefinition(accessors.Getter).GetParameters(); } else if (!accessors.Setter.IsNil) { parameterHandles = module.metadata.GetMethodDefinition(accessors.Setter).GetParameters(); } else { parameterHandles = null; } var(returnType, parameters) = MetadataMethod.DecodeSignature(module, this, signature, parameterHandles); LazyInit.GetOrSet(ref this.returnType, returnType); LazyInit.GetOrSet(ref this.parameters, parameters); }
MemberList GetMemberList() { var result = LazyInit.VolatileRead(ref this.memberList); if (result != null) { return(result); } List <IUnresolvedMember> unresolvedMembers = new List <IUnresolvedMember>(); List <ITypeResolveContext> contextPerMember = new List <ITypeResolveContext>(); List <PartialMethodInfo> partialMethodInfos = null; bool addDefaultConstructorIfRequired = false; foreach (IUnresolvedTypeDefinition part in parts) { ITypeResolveContext parentContextForPart = part.CreateResolveContext(parentContext); ITypeResolveContext contextForPart = parentContextForPart.WithCurrentTypeDefinition(this); foreach (var member in part.Members) { IUnresolvedMethod method = member as IUnresolvedMethod; if (method != null && method.IsPartial) { // Merge partial method declaration and implementation if (partialMethodInfos == null) { partialMethodInfos = new List <PartialMethodInfo>(); } PartialMethodInfo newInfo = new PartialMethodInfo(method, contextForPart); PartialMethodInfo existingInfo = null; foreach (var info in partialMethodInfos) { if (newInfo.IsSameSignature(info, Compilation.NameComparer)) { existingInfo = info; break; } } if (existingInfo != null) { // Add the unresolved method to the PartialMethodInfo: existingInfo.AddPart(method, contextForPart); } else { partialMethodInfos.Add(newInfo); } } else { unresolvedMembers.Add(member); contextPerMember.Add(contextForPart); } } addDefaultConstructorIfRequired |= part.AddDefaultConstructorIfRequired; } if (addDefaultConstructorIfRequired) { TypeKind kind = this.Kind; if (kind == TypeKind.Class && !this.IsStatic && !unresolvedMembers.Any(m => m.SymbolKind == SymbolKind.Constructor && !m.IsStatic) || kind == TypeKind.Enum || kind == TypeKind.Struct) { contextPerMember.Add(parts[0].CreateResolveContext(parentContext).WithCurrentTypeDefinition(this)); unresolvedMembers.Add(DefaultUnresolvedMethod.CreateDefaultConstructor(parts[0])); } } result = new MemberList(contextPerMember, unresolvedMembers, partialMethodInfos); return(LazyInit.GetOrSet(ref this.memberList, result)); }