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));
}
}
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);
}
}
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));
}
}
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));
}
