internal override InvalidInfo CheckValid(ValidityContext vctxt, MessageContext ctxt, RootEnvironment rootEnv)
{
var v = base.CheckValid(vctxt, ctxt, rootEnv);
if (v != null)
{
return(v);
}
var typeEnv = DefiningType.Enter(rootEnv);
var methodDef = typeEnv.Type.ResolveMethod(signature);
if (methodDef == null)
{
vctxt.Log(new InvalidMemberRef(ctxt, this, "No such method in defining type"));
return(new InvalidInfo(MessageContextBuilders.Member(vctxt.Global, this)));
}
var methEnv = typeEnv.AddMethod(methodDef).AddSelfMethodBoundArguments();
v = signature.CheckValid(vctxt, ctxt, methEnv);
if (v != null)
{
return(v);
}
return(vctxt.ImplementableMemberRef(ctxt, rootEnv, this));
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
var hash = DefiningType.GetHashCode() * 397;
hash ^= StringComparer.Ordinal.GetHashCode(Name);
return(hash);
}
}
public override MemberRef Generalize(RootEnvironment rootEnv)
{
var methodTypeArguments = default(Seq <TypeRef>);
if (MethodTypeArguments.Count > 0)
{
methodTypeArguments = MethodTypeArguments.Select(t => t.Generalize(rootEnv)).ToSeq();
}
return(new MethodRef(Annotations, DefiningType.Generalize(rootEnv), signature, methodTypeArguments));
}
public PropertyEnvironment Enter(RootEnvironment rootEnv)
{
var typeEnv = DefiningType.Enter(rootEnv);
var propDef = typeEnv.Type.ResolveProperty(signature);
if (propDef == null)
{
throw new InvalidOperationException("unable to resolve property reference");
}
return(typeEnv.AddProperty(propDef));
}
public PolymorphicMethodEnvironment Enter(RootEnvironment rootEnv)
{
var typeEnv = DefiningType.Enter(rootEnv);
var methodDef = typeEnv.Type.ResolveMethod(signature);
if (methodDef == null)
{
throw new InvalidOperationException("unable to resolve polymorphic method reference");
}
return(typeEnv.AddMethod(methodDef));
}
/// <summary>
/// Determines whether this instance of <see cref="FieldId"/> refers to the same field as <paramref name="other"/>.
/// </summary>
public bool Equals(FieldId?other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
return(other != null &&
DefiningType.Equals(other.DefiningType) &&
StringComparer.Ordinal.Equals(Name, other.Name));
}
public EventEnvironment Enter(RootEnvironment rootEnv)
{
var typeEnv = DefiningType.Enter(rootEnv);
var eventDef = typeEnv.Type.ResolveEvent(signature);
if (eventDef == null)
{
throw new InvalidOperationException("unable to resolve event reference");
}
return(typeEnv.AddEvent(eventDef));
}
public FieldEnvironment Enter(RootEnvironment rootEnv)
{
var typeEnv = DefiningType.Enter(rootEnv);
var fieldDef = typeEnv.Type.ResolveField(signature);
if (fieldDef == null)
{
throw new InvalidOperationException("unable to resolve field reference");
}
return(typeEnv.AddField(fieldDef));
}
public MethodEnvironment EnterMethod(RootEnvironment rootEnv)
{
var typeEnv = DefiningType.Enter(rootEnv);
var methodDef = typeEnv.Type.ResolveMethod(signature);
if (methodDef == null)
{
throw new InvalidOperationException("unable to resolve method reference");
}
var groundArguments = rootEnv.SubstituteTypes(MethodTypeArguments);
return(typeEnv.AddMethod(methodDef).AddMethodBoundArguments(groundArguments));
}
/// <inheritdoc />
public override int GetHashCode()
{
unchecked
{
var hash = DefiningType.GetHashCode() * 397;
hash ^= StringComparer.Ordinal.GetHashCode(Name);
foreach (var parameter in Parameters)
{
hash ^= parameter.GetHashCode();
}
return(hash);
}
}
public override MemberRef PrimSubstitute(IImSeq <TypeRef> typeBoundArguments, IImSeq <TypeRef> methodBoundArguments)
{
var methodTypeArguments = default(Seq <TypeRef>);
if (MethodTypeArguments.Count > 0)
{
methodTypeArguments =
MethodTypeArguments.Select(type => type.PrimSubstitute(typeBoundArguments, methodBoundArguments)).
ToSeq();
}
return(new MethodRef
(Annotations,
DefiningType.PrimSubstitute(typeBoundArguments, methodBoundArguments),
signature,
methodTypeArguments));
}
/// <summary>
/// Determines whether this instance of <see cref="PropertyId"/> refers to the same property of indexer as <paramref name="other"/>.
/// </summary>
public bool Equals(PropertyId?other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
if (other == null)
{
return(false);
}
return(DefiningType.Equals(other.DefiningType) &&
StringComparer.Ordinal.Equals(Name, other.Name) &&
Parameters.Count == other.Parameters.Count &&
Parameters.SequenceEqual(other.Parameters));
}
/// <summary>
/// Determines whether this instance of <see cref="MethodId"/> refers to the same method as <paramref name="other"/>.
/// </summary>
public bool Equals(MethodId?other)
{
if (ReferenceEquals(this, other))
{
return(true);
}
if (other == null)
{
return(false);
}
return(DefiningType.Equals(other.DefiningType) &&
StringComparer.Ordinal.Equals(Name, other.Name) &&
Arity == other.Arity &&
Parameters.SequenceEqual(other.Parameters) &&
(
(ReturnType == null && other.ReturnType == null) ||
(ReturnType != null && ReturnType.Equals(other.ReturnType))
));
}
internal override InvalidInfo CheckValid(ValidityContext vctxt, MessageContext ctxt, RootEnvironment rootEnv)
{
var v = base.CheckValid(vctxt, ctxt, rootEnv);
if (v != null)
{
return(v);
}
if (MethodTypeArguments.Count != MethodTypeArity)
{
vctxt.Log
(new InvalidMemberRef
(ctxt,
this,
String.Format
("Polymorphic method has {0} type parameters but is applied to {1} type arguments",
MethodTypeArity,
MethodTypeArguments.Count)));
return(new InvalidInfo(MessageContextBuilders.Member(vctxt.Global, this)));
}
v = MethodTypeArguments.Select(t => t.CheckValid(vctxt, ctxt, rootEnv)).FirstOrDefault(v2 => v2 != null);
if (v != null)
{
return(v);
}
var groundMethodTypeArguments = rootEnv.SubstituteTypes(MethodTypeArguments);
var typeEnv = DefiningType.Enter(rootEnv);
var methodDef = typeEnv.Type.ResolveMethod(signature);
if (methodDef == null)
{
throw new InvalidOperationException("unable to resolve method");
}
var methEnv = typeEnv.AddMethod(methodDef).AddMethodBoundArguments(groundMethodTypeArguments);
return(signature.CheckValid(vctxt, ctxt, methEnv));
}
internal override InvalidInfo CheckValid(ValidityContext vctxt, MessageContext ctxt, RootEnvironment rootEnv)
{
var v = base.CheckValid(vctxt, ctxt, rootEnv);
if (v != null)
{
return(v);
}
var typeEnv = DefiningType.Enter(rootEnv);
var eventDef = typeEnv.Type.ResolveMember(signature);
if (eventDef == null)
{
throw new InvalidOperationException("unable to resolve event");
}
v = signature.CheckValid(vctxt, ctxt, typeEnv);
if (v != null)
{
return(v);
}
return(vctxt.ImplementableMemberRef(ctxt, rootEnv, this));
}
public override MemberRef ToConstructor()
{
return(new EventRef(Annotations, DefiningType.ToConstructor(), signature));
}
public override MemberRef Generalize(RootEnvironment rootEnv)
{
return(new EventRef(Annotations, DefiningType.Generalize(rootEnv), signature));
}
public override MemberRef PrimSubstitute(IImSeq <TypeRef> typeBoundArguments, IImSeq <TypeRef> methodBoundArguments)
{
return(new EventRef(Annotations, DefiningType.PrimSubstitute(typeBoundArguments, methodBoundArguments), signature));
}
public override void Append(CSTWriter w)
{
DefiningType.Append(w);
w.Append("::");
signature.Append(w, MethodTypeArguments);
}
public override MemberRef ToConstructor()
{
return(new PolymorphicMethodRef(Annotations, DefiningType.ToConstructor(), signature));
}
