static IReturnType Parse(IProjectContent pc, IEnumerator <string> tokenizer)
{
string typeName = tokenizer.Current;
if (typeName == null)
{
throw new ReflectionTypeNameSyntaxError("Unexpected end of type name");
}
tokenizer.MoveNext();
int typeParameterCount;
typeName = ReflectionClass.SplitTypeParameterCountFromReflectionName(typeName, out typeParameterCount);
IReturnType rt = new GetClassReturnType(pc, typeName, typeParameterCount);
if (tokenizer.Current == "[")
{
// this is a constructed type
List <IReturnType> typeArguments = new List <IReturnType>();
do
{
tokenizer.MoveNext();
if (tokenizer.Current != "[")
{
throw new ReflectionTypeNameSyntaxError("Expected '['");
}
tokenizer.MoveNext();
typeArguments.Add(Parse(pc, tokenizer));
if (tokenizer.Current != "]")
{
throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument");
}
tokenizer.MoveNext();
} while (tokenizer.Current == ",");
if (tokenizer.Current != "]")
{
throw new ReflectionTypeNameSyntaxError("Expected ']' after generic argument list");
}
tokenizer.MoveNext();
rt = new ConstructedReturnType(rt, typeArguments);
}
while (tokenizer.Current == ",")
{
tokenizer.MoveNext();
string token = tokenizer.Current;
if (token != null && token != "," && token != "[" && token != "]")
{
tokenizer.MoveNext();
}
}
return(rt);
}
static IReturnType Create(IProjectContent pc, Type type,
IEntity member,
bool createLazyReturnType,
ICustomAttributeProvider attributeProvider,
ref int typeIndex,
bool forceGenericType = true)
{
if (type.IsByRef)
{
// TODO: Use ByRefRefReturnType
return(Create(pc, type.GetElementType(), member, createLazyReturnType, attributeProvider, ref typeIndex));
}
else if (type.IsPointer)
{
typeIndex++;
return(new PointerReturnType(Create(pc, type.GetElementType(), member, createLazyReturnType, attributeProvider, ref typeIndex)));
}
else if (type.IsArray)
{
typeIndex++;
return(new ArrayReturnType(pc, Create(pc, type.GetElementType(), member, createLazyReturnType, attributeProvider, ref typeIndex), type.GetArrayRank()));
}
else if (type.IsGenericType && (forceGenericType || !type.IsGenericTypeDefinition))
{
IReturnType baseType = Create(pc, type.GetGenericTypeDefinition(), member, createLazyReturnType, attributeProvider, ref typeIndex, forceGenericType: false);
Type[] args = type.GetGenericArguments();
List <IReturnType> para = new List <IReturnType>(args.Length);
for (int i = 0; i < args.Length; ++i)
{
typeIndex++;
para.Add(Create(pc, args[i], member, createLazyReturnType, attributeProvider, ref typeIndex));
}
return(new ConstructedReturnType(baseType, para));
}
else if (type.IsGenericParameter)
{
IClass c = (member is IClass) ? (IClass)member : (member is IMember) ? ((IMember)member).DeclaringType : null;
if (c != null && type.GenericParameterPosition < c.TypeParameters.Count)
{
if (c.TypeParameters[type.GenericParameterPosition].Name == type.Name)
{
return(new GenericReturnType(c.TypeParameters[type.GenericParameterPosition]));
}
}
if (type.DeclaringMethod != null)
{
IMethod method = member as IMethod;
if (method != null)
{
if (type.GenericParameterPosition < method.TypeParameters.Count)
{
return(new GenericReturnType(method.TypeParameters[type.GenericParameterPosition]));
}
return(new GenericReturnType(new DefaultTypeParameter(method, type)));
}
}
return(new GenericReturnType(new DefaultTypeParameter(c, type)));
}
else
{
string name = type.FullName;
if (name == null)
{
throw new ApplicationException("type.FullName returned null. Type: " + type.ToString());
}
int typeParameterCount;
name = ReflectionClass.ConvertReflectionNameToFullName(name, out typeParameterCount);
if (typeParameterCount == 0 && name == "System.Object" && HasDynamicAttribute(attributeProvider, typeIndex))
{
return(new DynamicReturnType(pc));
}
if (!createLazyReturnType)
{
IClass c = pc.GetClass(name, typeParameterCount);
if (c != null)
{
return(c.DefaultReturnType);
}
// example where name is not found: pointers like System.Char*
// or when the class is in a assembly that is not referenced
}
return(new GetClassReturnType(pc, name, typeParameterCount));
}
}
public ReflectionMethod(MethodBase methodBase, ReflectionClass declaringType)
: base(declaringType, methodBase is ConstructorInfo ? "#ctor" : methodBase.Name)
{
if (methodBase is MethodInfo)
{
MethodInfo m = ((MethodInfo)methodBase);
this.ReturnType = ReflectionReturnType.Create(this, m.ReturnType, attributeProvider: m.ReturnTypeCustomAttributes);
}
else if (methodBase is ConstructorInfo)
{
this.ReturnType = DeclaringType.DefaultReturnType;
}
foreach (ParameterInfo paramInfo in methodBase.GetParameters())
{
this.Parameters.Add(new ReflectionParameter(paramInfo, this));
}
if (methodBase.IsGenericMethodDefinition)
{
foreach (Type g in methodBase.GetGenericArguments())
{
this.TypeParameters.Add(new DefaultTypeParameter(this, g));
}
int i = 0;
foreach (Type g in methodBase.GetGenericArguments())
{
ReflectionClass.AddConstraintsFromType(this.TypeParameters[i++], g);
}
}
ModifierEnum modifiers = ModifierEnum.None;
if (methodBase.IsStatic)
{
modifiers |= ModifierEnum.Static;
}
if (methodBase.IsPrivate) // I assume that private is used most and public last (at least should be)
{
modifiers |= ModifierEnum.Private;
}
else if (methodBase.IsFamily || methodBase.IsFamilyOrAssembly)
{
modifiers |= ModifierEnum.Protected;
}
else if (methodBase.IsPublic)
{
modifiers |= ModifierEnum.Public;
}
else
{
modifiers |= ModifierEnum.Internal;
}
if (methodBase.IsFinal)
{
modifiers |= ModifierEnum.Sealed;
}
else if (methodBase.IsAbstract)
{
modifiers |= ModifierEnum.Abstract;
}
else if (methodBase.IsVirtual)
{
if ((methodBase.Attributes & MethodAttributes.NewSlot) != 0)
{
modifiers |= ModifierEnum.Virtual;
}
else
{
modifiers |= ModifierEnum.Override;
}
}
this.Modifiers = modifiers;
ReflectionClass.AddAttributes(declaringType.ProjectContent, this.Attributes, CustomAttributeData.GetCustomAttributes(methodBase));
ApplySpecialsFromAttributes(this);
}
