private void resolve(Context ctx)
{
Action check = () =>
{
if (Expression == null && !m_IsStatic)
Error(CompilerMessages.DynamicMemberFromStaticContext, MemberName);
if(m_Method == null && TypeHints.Count > 0)
Error(CompilerMessages.TypeArgumentsForNonMethod, m_Type, MemberName);
m_IsResolved = true;
};
m_Type = StaticType != null
? ctx.ResolveType(StaticType)
: Expression.GetExpressionType(ctx);
// special case: array length
if (m_Type.IsArray && MemberName == "Length")
{
check();
return;
}
// check for field
try
{
m_Field = ctx.ResolveField(m_Type, MemberName);
m_IsStatic = m_Field.IsStatic;
check();
return;
}
catch (KeyNotFoundException) { }
// check for property
try
{
m_Property = ctx.ResolveProperty(m_Type, MemberName);
if(!m_Property.CanGet)
Error(CompilerMessages.PropertyNoGetter, m_Type, MemberName);
m_IsStatic = m_Property.IsStatic;
check();
return;
}
catch (KeyNotFoundException)
{ }
var argTypes = TypeHints.Select(t => t.FullSignature == "_" ? null : ctx.ResolveType(t)).ToArray();
var methods = ctx.ResolveMethodGroup(m_Type, MemberName).Where(m => checkMethodArgs(ctx, argTypes, m)).ToArray();
if (methods.Length == 0)
Error(argTypes.Length == 0 ? CompilerMessages.TypeIdentifierNotFound : CompilerMessages.TypeMethodNotFound, m_Type.Name, MemberName);
if (methods.Length > 1)
Error(CompilerMessages.TypeMethodAmbiguous, m_Type.Name, MemberName);
m_Method = methods[0];
if (m_Method.ArgumentTypes.Length > 16)
Error(CompilerMessages.CallableTooManyArguments);
m_IsStatic = m_Method.IsStatic;
check();
}
private void detectEnumerableType(Context ctx)
{
var seqType = IterableExpression.GetExpressionType(ctx);
if (seqType.IsArray)
{
m_VariableType = seqType.GetElementType();
return;
}
var ifaces = GenericHelper.GetInterfaces(seqType);
if(!ifaces.Any(i => i == typeof(IEnumerable) || (i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IEnumerable<>))))
Error(IterableExpression, CompilerMessages.TypeNotIterable, seqType);
var enumerator = ctx.ResolveMethod(seqType, "GetEnumerator");
m_EnumeratorType = enumerator.ReturnType;
m_CurrentProperty = ctx.ResolveProperty(m_EnumeratorType, "Current");
m_VariableType = m_CurrentProperty.PropertyType;
}
private void resolve(Context ctx)
{
var type = StaticType != null
? ctx.ResolveType(StaticType)
: Expression.GetExpressionType(ctx);
SafeModeCheckType(ctx, type);
// check for field
try
{
m_Field = ctx.ResolveField(type, MemberName);
m_IsStatic = m_Field.IsStatic;
if (Expression == null && !m_IsStatic)
Error(CompilerMessages.DynamicMemberFromStaticContext, type, MemberName);
return;
}
catch (KeyNotFoundException) { }
try
{
m_Property = ctx.ResolveProperty(type, MemberName);
if(!m_Property.CanSet)
Error(CompilerMessages.PropertyNoSetter, MemberName, type);
m_IsStatic = m_Property.IsStatic;
if (Expression == null && !m_IsStatic)
Error(CompilerMessages.DynamicMemberFromStaticContext, MemberName, type);
}
catch (KeyNotFoundException)
{
Error(CompilerMessages.TypeSettableIdentifierNotFound, type, MemberName);
}
}
