public override int GetHashCode()
{
var hash = 17;
hash = hash * 23 + (Name != null ? Name.GetHashCode() : 0);
hash = hash * 23 + (FieldType != null ? FieldType.GetHashCode() : 0);
hash = hash * 23 + IsTransient.GetHashCode();
hash = hash * 23 + (DeclaringType != null ? DeclaringType.GetHashCode() : 0);
return(hash);
}
public void Initialize()
{
this.codeGenerator = new LLVMCodeGenerator(this);
ParentMethod = GetParentMethod(this);
if (ParentMethod == this &&
this.GetIsVirtual() &&
!DeclaringType.GetIsInterface())
{
ParentType.RelativeVTable.CreateRelativeSlot(this);
}
}
public override string ToString()
{
var declaringType = DeclaringType.ToCppMangling();
var functionParams = _parameterList
.Select(par => par.ToCppMangling())
.ToArray();
var paramString = string.Join(", ", functionParams);
return(string.Format(
"{0}.{1}({2})", declaringType, _methodName, paramString));
}
/// <summary>
/// GetHashCode override
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
if (this.Name == null)
{
return(DeclaringType.GetHashCode());
}
else
{
return(this.Name.GetHashCode());
}
}
/// <summary>
/// Gets the property to which the attribute's target is redirected, throwing an exception if the property does not exist.
/// </summary>
/// <returns>The property to which the attribute's target is redirected.</returns>
/// <exception cref="MappingException">The property does not exist.</exception>
public PropertyInfo GetMappedProperty()
{
var mappedProperty = DeclaringType.GetProperty(MappedPropertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
if (mappedProperty == null)
{
var message = string.Format("The member redirects LINQ queries to '{0}.{1}', which does not exist.", DeclaringType, MappedPropertyName);
throw new MappingException(message);
}
return(mappedProperty);
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
var hashCode = Method.GetHashCode();
hashCode = (hashCode * 397) ^ TargetMethod.GetHashCode();
hashCode = (hashCode * 397) ^ DeclaringType.GetHashCode();
hashCode = (hashCode * 397) ^ TargetType.GetHashCode();
hashCode = (hashCode * 397) ^ (int)InvocationType;
return(hashCode);
}
}
public virtual bool Equals(FunctorInfo other)
{
if (!DeclaringType.Equals(other.DeclaringType))
{
return(false);
}
if (!Name.Equals(other.Name))
{
return(false);
}
return(true);
}
public virtual string GetSignatureForError()
{
var bf = MemberDefinition as Property.BackingField;
string name;
if (bf == null) {
name = Name;
} else {
name = bf.OriginalProperty.MemberName.Name;
}
return DeclaringType.GetSignatureForError () + "." + name;
}
internal MethodInfo GetMethod()
{
MethodInfo meth =
ArgumentTypes == null
? DeclaringType.GetMethod(MethodName, Helper.flag1)
: DeclaringType.GetMethod(MethodName, Helper.flag1, null, ArgumentTypes, null);
return
meth.IsGenericMethod && GenericArguments != null && GenericArguments.Length > 0
? meth.MakeGenericMethod(GenericArguments)
: meth;
}
protected override MemberInfo ToMemberCore(Epyt[] genericArguments)
{
var n = _parameterTypes.Length;
var parameterTypes = new Type[n];
for (var i = 0; i < n; i++)
{
parameterTypes[i] = _parameterTypes[i].ToType(genericArguments);
}
var returnType = _returnType.ToType(genericArguments);
var declaringType = DeclaringType.ToType(genericArguments);
#if USE_SLIM
return(declaringType.GetSimpleMethod(_name, new ReadOnlyCollection <Type>(parameterTypes), returnType));
#else
var methods = declaringType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static);
foreach (var method in methods)
{
if (method.Name == _name)
{
if (method.ReturnType == returnType)
{
var pars = method.GetParameters();
if (pars.Length == n)
{
var found = true;
for (var i = 0; i < n; i++)
{
if (pars[i].ParameterType != parameterTypes[i])
{
found = false;
break;
}
}
if (found)
{
return(method);
}
}
}
}
}
throw new InvalidOperationException("Method not found.");
#endif
}
/// <inheritdoc/>
public override bool Match(PathSegment other)
{
KeySegment otherKeySegment = other as KeySegment;
if (otherKeySegment == null)
{
return(false);
}
// Compare the key segment using It's declaring type.
return(DeclaringType.FullTypeName() == otherKeySegment.DeclaringType.FullTypeName());
}
protected virtual void EnsureContextIsAssignanbleFromDeclaringType()
{
if (Context != null)
{
Type contextType = Context.GetType();
if (!DeclaringType.IsAssignableFrom(contextType))
{
throw new MemberAccessException(string.Format("The type {0} is not assignable from type {1}", DeclaringType.Name, contextType));
}
}
}
public DmdEventDefCOMD(DmdComMetadataReader reader, uint rid, DmdType declaringType, DmdType reflectedType) : base(rid, declaringType, reflectedType)
{
this.reader = reader ?? throw new ArgumentNullException(nameof(reader));
reader.Dispatcher.VerifyAccess();
uint token = 0x14000000 + rid;
Name = MDAPI.GetEventName(reader.MetaDataImport, token) ?? string.Empty;
Attributes = MDAPI.GetEventAttributes(reader.MetaDataImport, token);
var eventTypeToken = MDAPI.GetEventTypeToken(reader.MetaDataImport, token);
EventHandlerType = reader.ResolveType((int)eventTypeToken, DeclaringType.GetGenericArguments(), null, DmdResolveOptions.None) ?? reader.Module.AppDomain.System_Void;
}
public sealed override DmdMethodInfo GetGenericMethodDefinition()
{
if (!IsGenericMethodDefinition)
{
throw new InvalidOperationException();
}
if ((object)ReflectedType == DeclaringType)
{
return(this);
}
return(DeclaringType.GetMethod(Module, MetadataToken) as DmdMethodInfo ?? throw new InvalidOperationException());
}
private void CompleteResolver(
ICompletionContext context,
ObjectFieldDefinition definition)
{
bool isIntrospectionField = IsIntrospectionField ||
DeclaringType.IsIntrospectionType();
Resolver = definition.Resolver;
if (!isIntrospectionField || Resolver == null)
{
// gets resolvers that were provided via type extensions,
// explicit resolver results or are provided through the
// resolver compiler.
FieldResolver resolver =
context.GetResolver(definition.Name);
Resolver = GetMostSpecificResolver(
context.Type.Name, Resolver, resolver);
}
IReadOnlySchemaOptions options = context.DescriptorContext.Options;
bool skipMiddleware =
options.FieldMiddleware == FieldMiddlewareApplication.AllFields
? false
: isIntrospectionField;
Middleware = FieldMiddlewareCompiler.Compile(
context.GlobalComponents,
definition.MiddlewareComponents.ToArray(),
Resolver,
skipMiddleware);
if (Resolver == null && Middleware == null)
{
if (_executableDirectives.Any())
{
Middleware = ctx => Task.CompletedTask;
}
else
{
context.ReportError(SchemaErrorBuilder.New()
.SetMessage(
$"The field `{context.Type.Name}.{Name}` " +
"has no resolver.")
.SetCode(ErrorCodes.Schema.NoResolver)
.SetTypeSystemObject(context.Type)
.AddSyntaxNode(definition.SyntaxNode)
.Build());
}
}
}
public override MemberInfo FromNode([Optional] Container container)
{
var constructorParamNames = Parameters.Select(e => e.Name);
var constructorParamTypes = Parameters.Select(e => e.ParameterType.FromNode());
var restoredType = Arguments != null?DeclaringType.FromNode().MakeGenericType(Arguments.Select(e => e.FromNode()).ToArray()) : DeclaringType.FromNode();
var constructor = restoredType.GetConstructors().Where(e => e.GetParameters().Select(f => f.Name).OrderBy(x => x).SequenceEqual(constructorParamNames.OrderBy(y => y)) &&
e.GetParameters().Select(f => f.ParameterType).OrderBy(x => x).SequenceEqual(constructorParamTypes.OrderBy(y => y))).Single(e => e.Name == Name);
return(constructor);
}
protected override void ResolveMethod()
{
var @delegate = MethodResolver() as Delegate;
var method = @delegate.Method;
var types = method.GetParameters()
.Skip(1)
.Select(p => p.ParameterType)
.ToArray();
DeclaringType = method.ReturnType;
_ctor = DeclaringType.GetConstructor(types);
}
private bool IsProxyShouldBeCreated()
{
var defaultConstructor = DeclaringType.GetConstructor(Type.EmptyTypes);
if (defaultConstructor != null)
{
MethodDefinition methodDefinition = defaultConstructor.ResolveConstructorDefinition();
return(ConstructorHasStatement(methodDefinition));
}
return(true);
}
public override int GetHashCode()
{
unchecked {
var hashCode = IsSignatureTarget.GetHashCode();
hashCode = (hashCode * 397) ^ (DeclaringNamespace == null ? 0 : DeclaringNamespace.GetHashCode());
hashCode = (hashCode * 397) ^ (DeclaringType == null ? 0 : DeclaringType.GetHashCode());
hashCode = (hashCode * 397) ^ (Name == null ? 0 : Name.GetHashCode());
hashCode = (hashCode * 397) ^ (Data == null ? 0 : Data.GetCollectionHashCode(_exclusions));
hashCode = (hashCode * 397) ^ (GenericArguments == null ? 0 : GenericArguments.GetCollectionHashCode());
hashCode = (hashCode * 397) ^ (Parameters == null ? 0 : Parameters.GetCollectionHashCode());
return(hashCode);
}
}
public override int GetHashCode()
{
unchecked {
var hashCode = IsSignatureTarget.GetHashCode();
hashCode = (hashCode * 397) ^ (DeclaringNamespace?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (DeclaringType?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (Name?.GetHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (Data?.GetCollectionHashCode(new[] { "ILOffset", "NativeOffset" }) ?? 0);
hashCode = (hashCode * 397) ^ (GenericArguments?.GetCollectionHashCode() ?? 0);
hashCode = (hashCode * 397) ^ (Parameters?.GetCollectionHashCode() ?? 0);
return(hashCode);
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = DeclaringType != null?DeclaringType.GetHashCode() : 0;
hashCode = (hashCode * 397) ^ (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (FullName != null ? FullName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Type != null ? Type.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (int)Visibility;
return(hashCode);
}
}
public DmdEventDefMD(DmdEcma335MetadataReader reader, uint rid, DmdType declaringType, DmdType reflectedType) : base(rid, declaringType, reflectedType)
{
this.reader = reader ?? throw new ArgumentNullException(nameof(reader));
var row = reader.TablesStream.ReadEventRow(rid);
Name = reader.StringsStream.ReadNoNull(row.Name);
Attributes = (DmdEventAttributes)row.EventFlags;
if (!CodedToken.TypeDefOrRef.Decode(row.EventType, out uint token))
{
token = uint.MaxValue;
}
EventHandlerType = reader.ResolveType((int)token, DeclaringType.GetGenericArguments(), null, DmdResolveOptions.None) ?? reader.Module.AppDomain.System_Void;
}
public bool Equals(ConstructorDefinition other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
// Check if other is a null reference by using ReferenceEquals because
// we overload the == operator. If other isn't actually null then
// we get an infinite loop where we're constantly trying to compare to null.
return(!ReferenceEquals(other, null) &&
DeclaringType.Equals(other.DeclaringType) &&
Parameters.SequenceEqual(other.Parameters));
}
public DmdFieldDefMD(DmdEcma335MetadataReader reader, uint rid, DmdType declaringType, DmdType reflectedType) : base(rid, declaringType, reflectedType)
{
this.reader = reader ?? throw new ArgumentNullException(nameof(reader));
var row = reader.TablesStream.ReadFieldRow(rid);
Attributes = (DmdFieldAttributes)row.Flags;
Name = reader.StringsStream.ReadNoNull(row.Name);
FieldType = reader.ReadFieldType(row.Signature, DeclaringType.GetGenericArguments());
if (HasFieldRVA)
{
var rvaRow = reader.TablesStream.ReadFieldRVARow(reader.Metadata.GetFieldRVARid(rid));
FieldRVA = rvaRow?.RVA ?? 0;
}
}
/// <inheritdoc/>
public override void AcceptVisitor(IProxyDefinitionVisitor proxyDefinitionVisitor)
{
base.AcceptVisitor(proxyDefinitionVisitor);
// Visit declaring type method.
var methodInfo = DeclaringType.GetMethod(
DelegateMethodName,
BindingFlags.Public | BindingFlags.Instance);
proxyDefinitionVisitor.VisitMethod(methodInfo);
// Visit parent type members.
proxyDefinitionVisitor.VisitMembers(ParentType);
}
public override bool Equals(Object obj)
{
if (obj == this)
{
return(true);
}
if (!GetType().Equals(obj.GetType()))
{
return(false);
}
MemberEnhancementHint other = (MemberEnhancementHint)obj;
return(DeclaringType.Equals(other.DeclaringType) && MemberName.Equals(other.MemberName));
}
public override object? Invoke(object? obj, BindingFlags invokeAttr, Binder? binder, object?[]? parameters, CultureInfo? culture)
{
if (obj == null)
{
if (!IsStatic)
throw new TargetException("Instance constructor requires a target");
}
else if (!DeclaringType.IsInstanceOfType(obj))
{
throw new TargetException("Constructor does not match target type");
}
return DoInvoke(obj, invokeAttr, binder, parameters, culture);
}
protected virtual IEnumerable <Member> LookupDependencies()
{
var metadata = FeatureProvider.GetMetadata(DeclaringType.UnderlyingType);
if (metadata != null)
{
var namesOfPropsWeDependOn = metadata.GetMemberDependencies(this.Name);
return(namesOfPropsWeDependOn.Select(s => DeclaringType.GetMember(s)));
}
else
{
return(new List <Member>());
}
}
public override int GetHashCode()
{
unchecked
{
var hashCode = IsVirtual.GetHashCode();
hashCode = (hashCode * 397) ^ (Type != null ? Type.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Getter != null ? Getter.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Setter != null ? Setter.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (Name != null ? Name.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (FullName != null ? FullName.GetHashCode() : 0);
hashCode = (hashCode * 397) ^ (DeclaringType != null ? DeclaringType.GetHashCode() : 0);
return(hashCode);
}
}
public override Json.Expression ToJson(SerializationDomain domain)
{
var declType = DeclaringType.ToJson();
if (!domain.IsV08)
{
var indexParameterTypes = _property.IndexParameterTypes;
var indexParameterCount = indexParameterTypes.Count;
var indexParameterList = new Json.Expression[indexParameterCount];
for (var i = 0; i < indexParameterCount; i++)
{
indexParameterList[i] = domain.AddType(indexParameterTypes[i]).ToJson();
}
var indexParameters = Json.Expression.Array(indexParameterList);
if (_property.PropertyType != null)
{
var propType = domain.AddType(_property.PropertyType).ToJson();
return(Json.Expression.Array(
Discriminators.MemberInfo.PropertyDiscriminator,
declType,
Json.Expression.String(_property.Name),
indexParameters,
propType
));
}
else
{
return(Json.Expression.Array(
Discriminators.MemberInfo.PropertyDiscriminator,
declType,
Json.Expression.String(_property.Name),
indexParameters
));
}
}
else
{
return(Json.Expression.Array(
Discriminators.MemberInfo.PropertyDiscriminator,
declType,
Json.Expression.String(_property.Name)
));
}
}
