public override object Exec(TypeExpression operand1, object arg)
{
if (this.operand2 == operand1)
{
return(true);
}
TypeVariable typeVariable = this.operand2 as TypeVariable;
if (typeVariable != null)
{
return(typeVariable.AcceptOperation(new EquivalentOperation(operand1), arg));
}
FieldType fieldType = this.operand2 as FieldType;
if (fieldType != null)
{
return(fieldType.AcceptOperation(this, arg));
}
UnionType unionType = this.operand2 as UnionType;
if (unionType != null)
{
return(this.operand2.FullName.Contains(operand1.FullName));
}
return(operand1.FullName.Equals(this.operand2.FullName));
}
public override object Exec(TypeExpression operand1, object arg)
{
if (this.operand2 == operand1)
{
return(true);
}
TypeVariable typeVariable = this.operand2 as TypeVariable;
if (typeVariable != null)
{
return(typeVariable.AcceptOperation(new EquivalentOperation(operand1), arg));
}
return(operand1.FullName.Equals(this.operand2.FullName));
}
public override object Exec(MethodType operand1, object arg)
{
if (operand1 == this.operand2)
{
return(true);
}
TypeVariable typeVariable = this.operand2 as TypeVariable;
if (typeVariable != null)
{
return(typeVariable.AcceptOperation(new EquivalentOperation(operand1), arg));
}
MethodType method = this.operand2 as MethodType;
// * It must be a method
if (method == null)
{
return(false);
}
// * Same name
if (!operand1.MemberInfo.MemberIdentifier.Equals(method.MemberInfo.MemberIdentifier))
{
return(false);
}
// * Same class
if (!(bool)operand1.MemberInfo.Class.AcceptOperation(new EquivalentOperation(method.MemberInfo.Class), null))
{
return(false);
}
// * Same signature
if (operand1.ParameterListCount != method.ParameterListCount)
{
return(false);
}
for (int i = 0; i < operand1.ParameterListCount; i++)
{
if (!(bool)operand1.GetParameter(i).AcceptOperation(new EquivalentOperation(method.GetParameter(i)), null))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Performs an assigment operation between a FieldType type and the typeExpression stored in this.rightOperand.
/// The result of the operation is the resulting operation of doing PromotionOperation the operation.
/// </summary>
/// <param name="leftOperand">A FieldType, the left operand of the assignment/param>
/// <returns> The result of the operation is the resulting operation of doing The Assignment operation.
///</returns>
public override object Exec(FieldType leftOperand, object arg)
{
// * We check if a constraint must be generated. Is it an assignment of the implicit object's field?
bool found = false;
// * In case it has free variables and the reference used is this, we add a constraint to the method
if (leftOperand.HasTypeVariables() && this.methodAnalyzed != null &&
ClassType.IsConcreteType(this.actualImplicitObject) == null)
{
// * They should be the same exact (sub)classes. This represent the same instance, not another instance of the same class.
ClassType methodSuperClass = (ClassType)this.methodAnalyzed.MemberInfo.Class;
while (!(found = (leftOperand.MemberInfo.Class == methodSuperClass)) && methodSuperClass != null)
{
methodSuperClass = methodSuperClass.BaseClass;
}
if (found)
{
// * An assignment constraint is added, postponing the type inference
// * If an actual implicit object is used, we take its field's type
FieldType fieldType = leftOperand;
ClassType thisType = TypeExpression.As <ClassType>(this.actualImplicitObject);
if (thisType == null)
{
FieldType field = TypeExpression.As <FieldType>(this.actualImplicitObject);
if (field != null)
{
thisType = TypeExpression.As <ClassType>(field.FieldTypeExpression);
}
}
if (thisType != null)
{
while (thisType != null && !thisType.Fields.ContainsKey(leftOperand.MemberInfo.MemberIdentifier))
{
thisType = thisType.BaseClass;
}
if (thisType != null)
{
fieldType = (FieldType)thisType.Fields[leftOperand.MemberInfo.MemberIdentifier].Type;
}
}
this.methodAnalyzed.AddConstraint(new FieldTypeAssignmentConstraint(fieldType, this.rightOperand,
this.unification));
this.methodAnalyzed.ValidTypeExpression = false;
if (leftOperand.FieldTypeExpression is TypeVariable && rightOperand is ArrayType)
{
TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
typeVariable.AcceptOperation(new AssignmentOperation(rightOperand, this.op, null, SortOfUnification.Override, null, this.location), arg);
}
else if (leftOperand.FieldTypeExpression is TypeVariable && TypeExpression.As <ClassType>(rightOperand) != null && ((TypeVariable)leftOperand.FieldTypeExpression).IsDynamic)
{
TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
typeVariable.AcceptOperation(new AssignmentOperation(rightOperand, this.op, null, SortOfUnification.Override, null, this.location), arg);
}
else if (leftOperand.FieldTypeExpression is TypeVariable && rightOperand is TypeVariable && ((TypeVariable)rightOperand).Substitution == null && ((TypeVariable)rightOperand).IsDynamic)
{
TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
typeVariable.AcceptOperation(new AssignmentOperation(rightOperand, this.op, null, SortOfUnification.Override, null, this.location), arg);
}
return(leftOperand.FieldTypeExpression);
}
if (leftOperand.FieldTypeExpression is TypeVariable)
{
TypeVariable typeVariable = (TypeVariable)leftOperand.FieldTypeExpression;
if (typeVariable.Substitution != null)
{
return
(leftOperand.FieldTypeExpression.AcceptOperation(
new AssignmentOperation(this.rightOperand, this.op, null,
SortOfUnification.Incremental, this.actualImplicitObject,
this.location), arg));
}
}
}
if (leftOperand.FieldTypeExpression != null)
{
return
(leftOperand.FieldTypeExpression.AcceptOperation(
new AssignmentOperation(this.rightOperand, this.op, null, this.unification,
this.actualImplicitObject, this.location), arg));
}
return(null);
}