/// <summary>
/// Finds the declaration inside the compositions and calls the base method too
/// </summary>
/// <param name="typeBase">the type of the object</param>
/// <param name="memberName">the name of its member</param>
/// <returns>a collection of all possible members</returns>
protected override IEnumerable<IDeclaration> FindDeclarationsFromObject(TypeBase typeBase, string memberName)
{
if (typeBase == null)
{
yield break;
}
// look if it is a composition
// the typebase is unique for each extern so there is no need to look for the right class
//var mixin = compositionsVirtualTables.FirstOrDefault(x => ReferenceEquals(x.Key.ResolveType(), typeBase.ResolveType())).Value;
var mixin = moduleMixins.FirstOrDefault(x => x.MixinName == typeBase.Name.Text);
if (mixin != null)
{
foreach (var member in mixin.VirtualTable.Variables.Where(x => x.Variable.Name.Text == memberName))
yield return member.Variable;
foreach (var member in mixin.VirtualTable.Methods.Where(x => x.Method.Name.Text == memberName))
yield return member.Method;
if (mixin.MixinName == memberName)
yield return mixin.Shader;
foreach (var dep in mixin.InheritanceList.Where(x => x.MixinName == memberName).Select(x => x.Shader))
yield return dep;
}
else
{
foreach (var item in base.FindDeclarationsFromObject(typeBase.ResolveType(), memberName))
yield return item;
}
}
/// <summary>
/// Find the base type in case of array
/// </summary>
/// <param name="typeBase">the type to explore</param>
/// <returns>the base type</returns>
private static TypeBase FindFinalType(TypeBase typeBase)
{
if (typeBase is ArrayType)
return FindFinalType((typeBase as ArrayType).Type);
return typeBase.ResolveType();
}
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <returns>The implicit conversion between between to two types</returns>
protected override TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
{
if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType())
return StreamsType.Streams;
return base.GetDivideImplicitConversionType(span, left, right);
}
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <param name="isBinaryOperator">if set to <c>true</c> [is binary operator].</param>
/// <returns>
/// The implicit conversion between between to two types
/// </returns>
protected override TypeBase GetBinaryImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right, bool isBinaryOperator)
{
if (left.ResolveType().IsStreamsType() || right.ResolveType().IsStreamsType())
return StreamsType.Streams;
return base.GetBinaryImplicitConversionType(span, left, right, isBinaryOperator);
}
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <returns>The implicit conversion between between to two types</returns>
protected virtual TypeBase GetDivideImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
{
var result = CastHelper.GetDivideImplicitConversionType(left.ResolveType(), right.ResolveType());
if (result == null)
Error(MessageCode.ErrorBinaryTypeDeduction, span, left, right);
return result;
}
/// <summary>
/// Gets the type of the binary implicit conversion.
/// </summary>
/// <param name="span">The span.</param>
/// <param name="left">The left.</param>
/// <param name="right">The right.</param>
/// <returns>The implicit conversion between between to two types</returns>
protected override TypeBase GetMultiplyImplicitConversionType(SourceSpan span, TypeBase left, TypeBase right)
{
if (left.ResolveType() is StreamsType || right.ResolveType() is StreamsType)
return StreamsType.Streams;
return base.GetMultiplyImplicitConversionType(span, left, right);
}
