public GenericInterPropertyWrapper(InterProperty property, IntermediateBuilder context, InterGenericType type)
: base(property, context)
{
_type = type;
_propertyType = _type.InstantiateGenericType(property.Type);
}
public virtual void Bind(IntermediateBuilder context)
{
if (Type == null)
{
Type = context.ResolveType(TypeName);
}
}
public override void Bind(IntermediateBuilder context)
{
if (_ids.Length == 1)
{
string name = _ids[0];
foreach (var field in Owner.Owner.Fields)
{
if (field.Name != name)
{
continue;
}
IsStatic = field.IsStatic;
_field = new FieldOrPropertySymbol(field.Symbol);
_field.Bind(context);
Type = _field.Type;
return;
}
//TODO: Add properties
}
int i = 0;
for (; i < _ids.Length; i++)
{
Type = context.ResolveType(new BasicTypeName(string.Join('.', _ids[0..(i + 1)]), _namespaceContext));
public virtual IEnumerable <IMethodWrapper> GetConstructors(IntermediateBuilder context)
{
foreach (var f in _type.GetConstructors())
{
yield return(new ConstructorInfoWrapper(f, context));
}
}
public virtual IEnumerable <IMethodWrapper> GetFunctions(IntermediateBuilder context)
{
foreach (var f in _type.GetMethods())
{
yield return(new MethodInfoWrapper(f, context));
}
}
public virtual IEnumerable <IFieldWrapper> GetFields(IntermediateBuilder context)
{
foreach (var f in _type.GetFields())
{
yield return(new FieldInfoWrapper(f, context));
}
}
public override IEnumerable <IMethodWrapper> GetFunctions(IntermediateBuilder context)
{
foreach (var f in typeof(string).GetMethods())
{
yield return(new MethodInfoWrapper(f, context));
}
}
public override IEnumerable <IFieldWrapper> GetFields(IntermediateBuilder context)
{
foreach (var f in _intertype.Fields)
{
yield return(new InterFieldWrapper(f));
}
}
public virtual IEnumerable <IPropertyWrapper> GetProperties(IntermediateBuilder context)
{
foreach (var f in _type.GetProperties())
{
yield return(new PropertyInfoWrapper(f, context));
}
}
public override IEnumerable <IMethodWrapper> GetConstructors(IntermediateBuilder context)
{
foreach (var f in _intertype.Constructors)
{
yield return(new InterMethodWrapper(f, context));
}
}
public override void Bind(IntermediateBuilder context)
{
_op1.Bind(context);
_op2.Bind(context);
CodeType wideType = _op1.Type.GetWiderType(_op2.Type);
if (wideType is UserType)
{
var user = UserType.ToUserType(wideType);
var overload = user.GetOperatorOverload(Op, context);
if (overload != null)
{
_overload = new InterCall(overload, new CodeValue[] { _op1, _op2 }, true);
_overload.SetOwner(Owner);
_overload.Bind(context);
return;
}
}
if (_op1.Type != wideType)
{
_op1 = new ConvertedValue(_op1, wideType, Owner); _op1.Bind(context);
}
if (_op2.Type != wideType)
{
_op2 = new ConvertedValue(_op2, wideType, Owner); _op2.Bind(context);
}
}
public override IEnumerable <IPropertyWrapper> GetProperties(IntermediateBuilder context)
{
foreach (var f in _intertype.Properties)
{
yield return(new InterPropertyWrapper(f, context));
}
}
public GenericInterMethodWrapper(InterMethod method, IntermediateBuilder context, InterGenericType type) : base(method, context)
{
_type = type;
if (method.ReturnType is GenericParameterType)
{
var par = method.ReturnType as GenericParameterType;
_returnType = new GenericParameterType(_type.GenericParameters[par.Index], par.Index);
}
else
{
_returnType = method.ReturnType;
}
_returnType = _type.InstantiateGenericType(method.ReturnType);
_args = new CodeType[method.Arguments.Length];
for (int i = 0; i < _args.Length; i++)
{
var p = method.Arguments[i];
p.Bind(context);
_args[i] = _type.InstantiateGenericType(p.Type);
}
}
public override void BindSubMembers(IntermediateBuilder builder)
{
foreach (var a in _baseArgs)
{
a.Bind(builder);
}
IMethodWrapper baseCon
= builder.FindMostApplicableConstructor(_callThis ? new InterUserType(Owner) : UserType.ToUserType(Owner.BaseType), _baseArgs);
AddInstruction(new InterCall(baseCon, _baseArgs, false, ThisPointer), 0);
foreach (var field in Owner.Fields)
{
if (field.IsStatic || field.Initializer == null)
{
continue;
}
AddInstruction(new InterCopy(field.Symbol, field.Initializer), 0);
}
base.BindSubMembers(builder);
}
public void Bind(IntermediateBuilder builder)
{
BaseType = builder.ResolveType(BaseTypeName);
if (Constructors.Count == 0)
{
Constructors.Add(new InterConstructor(this));
}
}
public override void Bind(IntermediateBuilder context)
{
base.Bind(context);
_op1.Bind(context);
_op2.Bind(context);
_exp.Bind(context);
}
public override void Bind(IntermediateBuilder context)
{
base.Bind(context);
if (hasValue)
{
_exp.Bind(context);
}
}
private IEnumerable <IDamageSpecification> BuildAilmentDamage(IntermediateBuilder intermediateBuilder)
{
if (_damageSource is DamageSource source && source != DamageSource.OverTime)
{
return(intermediateBuilder.BuildAilmentDamage(source));
}
return(Enums.GetValues <DamageSource>().SelectMany(intermediateBuilder.BuildAilmentDamage));
}
public override void Bind(IntermediateBuilder context)
{
base.Bind(context);
if (_typeName == TypeName.Unknown)
{
return;
}
_type = context.ResolveType(_typeName);
}
public virtual IEnumerable <IPropertyWrapper> GetIndexers(IntermediateBuilder context)
{
foreach (var f in _type.GetProperties())
{
if (f.GetIndexParameters().Length > 0)
{
yield return(new PropertyInfoWrapper(f, context));
}
}
}
public override void Bind(IntermediateBuilder context)
{
if (Type != null)
{
return;
}
_op.Bind(context);
Type = _op.GetResultType();
}
public override void Bind(IntermediateBuilder context)
{
_owner?.Bind(context);
if (Type != null)
{
return;
}
UserType type = (_owner != null ? _owner.Type : _owningType) as UserType;
if (_owningType == null)
{
_owningType = type;
}
IPropertyWrapper matchProperty = null;
var t = type;
while (matchProperty == null && t != CodeType.Object)
{
foreach (var f in t.GetProperties(context))
{
if (f.Name == ID)
{
matchProperty = f; break;
}
}
if (matchProperty == null)
{
t = t.GetBaseType();
}
}
_owningType = t;
Debug.Assert(matchProperty != null);
Type = matchProperty.Type;
Property = matchProperty;
if (Property.CanRead)
{
_get = new InterCall(Property.GetFunction, true, _owner);
_get.SetOwner(context.CurrentMethod);
}
if (Property.CanWrite)
{
_set = new InterCall(Property.SetFunction, true, _owner);
_set.SetOwner(context.CurrentMethod);
}
}
public override IMethodWrapper GetOperatorOverload(Operator op, IntermediateBuilder context)
{
if (op.Type == Operator.OperatorType.Add)
{
return(new MethodInfoWrapper(typeof(string).GetMethod("Concat", new Type[] { typeof(string), typeof(string) }), context));
}
else
{
return(base.GetOperatorOverload(op, context));
}
}
public override void Bind(IntermediateBuilder context)
{
if (_op == null)
{
base.Bind(context);
}
else
{
_op.Bind(context);
Type = _op.Type;
}
}
public virtual IMethodWrapper GetOperatorOverload(Operator op, IntermediateBuilder context)
{
foreach (var w in GetFunctions(context))
{
if (w.Name == op.GetOverloadName())
{
return(w);
}
}
return(null);
}
public override void BindSubMembers(IntermediateBuilder builder)
{
foreach (var field in Owner.Fields)
{
if (!field.IsStatic)
{
continue;
}
AddInstruction(new InterCopy(field.Symbol, field.Initializer));
}
base.BindSubMembers(builder);
}
public override void Bind(IntermediateBuilder context)
{
_owner?.Bind(context);
if (_owningTypeName != TypeName.Unknown)
{
_owningType = UserType.ToUserType(context.ResolveType(_owningTypeName));
}
if (Field != null)
{
Type = Field.Type; return;
}
UserType type = (_owningType != null ? _owningType : _owner.Type) as UserType;
if (_owningType == null)
{
_owningType = type;
}
IFieldWrapper matchField = null;
var t = type;
while (matchField == null && t != CodeType.Object)
{
foreach (var f in t.GetFields(context))
{
if (f.Name == ID)
{
matchField = f; break;
}
}
if (matchField == null)
{
t = t.GetBaseType();
}
}
_owningType = t;
//Debug.Assert(matchField != null);
if (matchField == null)
{
return;
}
Type = matchField.Type;
Field = matchField;
}
public void BindSubSubMembers(IntermediateBuilder builder)
{
Initializer.BindSubMembers(builder);
foreach (var constructor in Constructors)
{
constructor.BindSubMembers(builder);
}
foreach (var method in Methods)
{
method.BindSubMembers(builder);
}
}
public override void Bind(IntermediateBuilder context)
{
_field.Bind(context);
if (_field.Type == null)
{
IsProperty = true;
_property.Bind(context);
Type = _property.Type;
}
else
{
IsField = true;
Type = _field.Type;
}
}
public override IMethodWrapper GetConversionMethod(IntermediateBuilder context, CodeValue from)
{
UserType user = UserType.ToUserType(from.Type);
IMethodWrapper match = null;
foreach (var f in user.GetFunctions(context))
{
if (f.Name == "ToString")
{
match = f; break;
}
}
Debug.Assert(match != null);
return(match);
}
