private void CheckStatic(MethodCallExpression e, TypeCheckingContext context)
{
Type[] parameterClasses = e.Parameters.Select(i => i.Type).ToArray();
e.Method = ReflectionSnippets.FindMethod(e.OwnerType, e.MethodName, parameterClasses);
if (e.Method == null)
{
StringBuilder paramList = new StringBuilder();
foreach (Type type in parameterClasses)
{
paramList.Append(type).Append(",");
}
if (parameterClasses.Length > 0)
{
paramList.Remove(paramList.Length - 1, 1);
}
StringBuilder locations = new StringBuilder();
locations.Append(e.OwnerType).Append("\r\n");
context.ErrorProvider.ThrowException(string.Format("Method {0}.{1}({2}) cannot be found.\r\nSearched the following location:\r\n{3}",
e.OwnerType,
e.MethodName,
paramList,
locations), e);
}
}
private void CheckNonStatic(MethodCallExpression e, TypeCheckingContext context)
{
PerformTypeChecking(e.Operand, context);
Type[] parameterClasses = e.Parameters.Select(i => i.Type).ToArray();
e.Method = ReflectionSnippets.FindMethod(e.Operand.Type, e.MethodName, parameterClasses);
if (e.Method == null && context.VariableContext != null)
{
e.Method = context.VariableContext.SearchMethod(e.MethodName, e.Operand.Type, parameterClasses);
e.IsExtension = true;
}
if (e.Method == null)
{
StringBuilder list1 = new StringBuilder();
foreach (Type type in parameterClasses)
{
list1.Append(type).Append(",");
}
if (parameterClasses.Length > 0)
{
list1.Remove(list1.Length - 1, 1);
}
StringBuilder list2 = new StringBuilder();
list2.Append(e.Operand.Type).Append(",");
foreach (Type type in parameterClasses)
{
list2.Append(type).Append(",");
}
list2.Remove(list2.Length - 1, 1);
StringBuilder locations = new StringBuilder();
locations.Append(e.Operand.Type).Append("\r\n");
foreach (Type type in context.VariableContext.GetMethodExtenders())
{
locations.Append(type).Append("\r\n");
}
context.ErrorProvider.ThrowException(string.Format("Method {0}.{1}({2}) or extension method {3}({4}) cannot be found.\r\nSearched the following locations:\r\n{5}",
e.Operand.Type,
e.MethodName,
list1,
e.MethodName,
list2,
locations), e);
}
}
private void CehckCreateObjectExpression(CreateObjectExpression e, TypeCheckingContext context)
{
foreach (Expression parameter in e.Parameters)
{
PerformTypeChecking(parameter, context);
}
foreach (ConstructorInfo c in e.ObjectType.GetConstructors())
{
bool isValid = true;
int i = 0;
foreach (ParameterInfo p in c.GetParameters())
{
if (!ReflectionSnippets.Accepts(p.ParameterType, e.Parameters[i].Type))
{
isValid = false;
break;
}
i++;
}
if (isValid)
{
e.Constructor = c;
break;
}
}
if (e.Constructor == null)
{
StringBuilder b = new StringBuilder();
foreach (Expression parameter in e.Parameters)
{
b.Append(parameter.Type).Append(",");
}
if (e.Parameters.Length > 0)
{
b.Remove(b.Length - 1, 1);
}
context.ErrorProvider.ThrowException(string.Format("{0}.ctor({1}) not found", e.ObjectType, b), e);
}
e.Type = e.ObjectType;
}
private void CheckCreateArrayExpression(CreateArrayExpression e, TypeCheckingContext context)
{
foreach (Expression element in e.Elements)
{
PerformTypeChecking(element, context);
Type type = element is CondensedArrayExpression?element.Type.GetElementType() : element.Type;
if (!ReflectionSnippets.Accepts(e.ElementType, type))
{
context.ErrorProvider.ThrowException(string.Format("{0} cannot be put into {1}[]", element.Type, e.ElementType), element);
}
}
e.Type = e.ElementType.MakeArrayType(0);
}
private void CheckIndexingExpression(IndexingExpression e, TypeCheckingContext context)
{
PerformTypeChecking(e.Operand, context);
PerformTypeChecking(e.Indexer, context);
if (!e.Operand.Type.IsArray)
{
context.ErrorProvider.ThrowException("Only array types can use [] operator.", e);
}
else if (!ReflectionSnippets.Accepts(typeof(int), e.Indexer.Type))
{
context.ErrorProvider.ThrowException("Indexer must be convertiable to int.", e);
}
else
{
e.Type = e.Operand.Type.GetElementType();
}
}
private void CheckCastExpression(CastExpression e, TypeCheckingContext context)
{
try
{
e.TargetType = Types.GetType(e.ClassName, LanguageService.GetImportedPackages());
}
catch
{
context.ErrorProvider.ThrowException(string.Format("{0} not defined.", e.ClassName), e);
}
PerformTypeChecking(e.Operand, context);
if (e.Operand.Type == null ? !Types.IsPrimitiveType(e.TargetType) : ReflectionSnippets.CanCast(e.TargetType, e.Operand.Type))
{
e.Type = e.TargetType;
}
else
{
context.ErrorProvider.ThrowException(string.Format("Cannot cast from {0} to {1}.", e.Operand.Type, e.TargetType), e);
}
}
