public CodeType ToCodeType(Type type, bool parseGenerics = true)
{
if (CodeType.ByName(type.Name.ToLower()) != null)
{
return(CodeType.ByName(type.Name.ToLower()));
}
UserType ut = null;
if (type.IsArray)
{
ut = new ArrayType(ToCodeType(type.GetElementType()));
}
else if (type.IsGenericType && parseGenerics)
{
CodeType[] parameters = new CodeType[type.GetGenericArguments().Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = new GenericParameterType(ToCodeType(type.GetGenericArguments()[i]), i);
}
ut = GenericType.NewGenericType(UserType.NewUserType(type), parameters);
}
else
{
ut = UserType.NewUserType(type);
}
if (ut != null)
{
ReferenceTracker.AddUsedReference(ut.GetAssembly());
}
return(ut);
}
private TypeName TypeNameFromNode(SyntaxTreeNode node)
{
switch (node.Op)
{
case "GenericType":
TypeName name = TypeNameFromNode(node[0]);
TypeName[] parameters = new TypeName[node[1].Children.Length];
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = TypeNameFromNode(node[1][i]);
}
return(new GenericTypeName(name, builder.CurrentNamespaceContext, parameters));
case "Array":
return(new ArrayTypeName(TypeNameFromNode(node[0]), builder.CurrentNamespaceContext));
case "Type":
return(new BasicTypeName(CodeType.ByName(node.ValueString).Name));
default:
return(new BasicTypeName(GetName(node), builder.CurrentNamespaceContext));
}
}
public CodeType ResolveType(TypeName name)
{
if (name is ArrayTypeName)
{
var array = name as ArrayTypeName;
return(new ArrayType(ResolveType(array.ElementType)));
}
else if (name is GenericTypeName)
{
var generic = name as GenericTypeName;
CodeType[] parameters = new CodeType[generic.GenericParameters.Length];
var genericName = UserType.ToUserType(ResolveType(new BasicTypeName(generic.baseName.Name + '`' + parameters.Length, generic.baseName.NamespaceContext)));
for (int i = 0; i < parameters.Length; i++)
{
parameters[i] = ResolveType(generic.GenericParameters[i]);
}
return(GenericType.NewGenericType(genericName, parameters));
}
if (name.NamespaceContext.GenericParameters.ContainsKey(name.Name))
{
return(name.NamespaceContext.GenericParameters[name.Name]);
}
var ctype = CodeType.ByName(name.Name);
if (ctype != null)
{
return(ctype);
}
foreach (string ns in name.NamespaceContext.TravelUpHierarchy())
{
foreach (InterType type in Types)
{
if (type.FullName == ns + '.' + name.Name)
{
return(new InterUserType(type));
}
}
}
foreach (string ns in ImportedNamespaces)
{
foreach (InterType type in Types)
{
if (type.FullName == ns + "." + name.Name)
{
return(new InterUserType(type));
}
}
foreach (var a in AssemblyReferences)
{
var directResolve = a.ResolveType(name.NamespaceContext.ToString() + '.' + name.Name);
if (directResolve != null)
{
return(UserType.NewUserType(directResolve));
}
foreach (string hr in name.NamespaceContext.TravelUpHierarchy())
{
var type = a.ResolveType(ns + "." + name.Name);
if (type != null)
{
ReferenceTracker.AddUsedReference(type);
return(UserType.NewUserType(type));
}
}
}
}
return(null);
}
