static IType CreateInstantiatedGenericTypeInternal(IType type, IList <IReturnType> genericArguments, GenericTypeInstanceResolver parent)
{
// This method is now internal. The public one has been moved to ProjectDom, which take cares of caching
// instantiated generic types.
if (type is InstantiatedType)
{
return(type);
}
string name = GetInstantiatedTypeName(type.Name, genericArguments);
GenericTypeInstanceResolver resolver = new GenericTypeInstanceResolver();
resolver.Parent = parent;
if (genericArguments != null)
{
int j = genericArguments.Count - 1;
IType curType = type;
while (curType != null)
{
string fullTypeName = curType.DecoratedFullName;
for (int i = curType.TypeParameters.Count - 1; i >= 0 && j >= 0; i--, j--)
{
resolver.Add(fullTypeName + "." + curType.TypeParameters [i].Name, genericArguments [j]);
}
curType = curType.DeclaringType;
}
}
AddInnerTypes(resolver, type.DecoratedFullName, type, genericArguments);
InstantiatedType result = (InstantiatedType)type.AcceptVisitor(resolver, type);
if (result.typeParameters != null)
{
result.typeParameters.Clear();
}
result.Name = name;
result.SourceProjectDom = type.SourceProjectDom;
result.Resolved = (type is DomType) ? ((DomType)type).Resolved : false;
result.GenericParameters = genericArguments;
result.UninstantiatedType = type;
result.DeclaringType = type.DeclaringType;
CreateInstantiatedSubtypes(result, type, genericArguments, resolver);
Dictionary <string, IType> typeTable = new Dictionary <string, IType> ();
Stack <IType> typeStack = new Stack <IType> ();
typeStack.Push(result);
while (typeStack.Count > 0)
{
IType cur = typeStack.Pop();
foreach (var inner in cur.InnerTypes)
{
typeStack.Push(inner);
}
var returnType = new DomReturnType(cur);
typeTable [returnType.ToInvariantString()] = cur;
}
result.AcceptVisitor(new SeedVisitor(), typeTable);
return(result);
}
static void AddInnerTypes(GenericTypeInstanceResolver resolver, string decoratedFullName, IType type, IList <IReturnType> genericArguments)
{
foreach (var inner in type.InnerTypes)
{
var constructedReturnType = new DomReturnType(type.Namespace, type.Name, false, genericArguments);
constructedReturnType.Parts.Add(new ReturnTypePart(inner.Name));
string constructedName = decoratedFullName + "." + inner.DecoratedFullName;
resolver.Add(constructedName, constructedReturnType);
AddInnerTypes(resolver, constructedName, inner, genericArguments);
}
}
public static IType CreateInstantiatedGenericTypeInternal(IType type, IList <IReturnType> genericArguments)
{
// This method is now internal. The public one has been moved to ProjectDom, which take cares of caching
// instantiated generic types.
if (type is InstantiatedType)
{
return(type);
}
string name = GetInstantiatedTypeName(type.Name, genericArguments);
GenericTypeInstanceResolver resolver = new GenericTypeInstanceResolver();
if (genericArguments != null)
{
int j = genericArguments.Count - 1;
IType curType = type;
while (curType != null)
{
string fullTypeName = curType.DecoratedFullName;
for (int i = curType.TypeParameters.Count - 1; i >= 0 && j >= 0; i--, j--)
{
resolver.Add(fullTypeName + "." + curType.TypeParameters[i].Name, genericArguments[j]);
}
curType = curType.DeclaringType;
}
}
InstantiatedType result = (InstantiatedType)type.AcceptVisitor(resolver, type);
if (result.typeParameters != null)
{
result.typeParameters.Clear();
}
result.Name = name;
result.SourceProjectDom = type.SourceProjectDom;
result.Resolved = (type is DomType) ? ((DomType)type).Resolved : false;
result.GenericParameters = genericArguments;
result.UninstantiatedType = type;
result.DeclaringType = type.DeclaringType;
CreateInstantiatedSubtypes(result, type, genericArguments);
return(result);
}
internal List <IType> ResolveTypeParameters(IEnumerable <IType> types)
{
List <IType> result = new List <IType> ();
foreach (IType type in types)
{
if (type.TypeParameters.Count == 0)
{
result.Add(type);
continue;
}
GenericTypeInstanceResolver resolver = new GenericTypeInstanceResolver();
string typeName = NamespaceEntry.GetDecoratedName(type);
foreach (TypeParameter par in type.TypeParameters)
{
resolver.Add(par.Name, new DomReturnType(NamespaceEntry.ConcatNamespaces(typeName, par.Name)));
}
resolver.Visit(type, type);
result.Add((IType)type.AcceptVisitor(resolver, type));
}
return(result);
}
static void CreateInstantiatedSubtypes(InstantiatedType result, IType curType, IList <IReturnType> genericArguments, GenericTypeInstanceResolver resolver)
{
foreach (IType innerType in curType.InnerTypes)
{
List <IReturnType> newArguments = new List <IReturnType> ();
List <int> removeInheritedArguments = new List <int> ();
for (int i = 0; i < innerType.TypeParameters.Count; i++)
{
ITypeParameter curParameter = innerType.TypeParameters [i];
bool found = false;
for (int j = curType.TypeParameters.Count - 1; j >= 0; j--)
{
if (curType.TypeParameters [j].Name == curParameter.Name)
{
removeInheritedArguments.Add(newArguments.Count);
newArguments.Add(genericArguments [j]);
found = true;
break;
}
}
if (!found)
{
newArguments.Add(new DomReturnType(curParameter.Name));
}
}
InstantiatedType innerInstantiatedType = (InstantiatedType)CreateInstantiatedGenericTypeInternal(innerType, newArguments, resolver);
for (int i = 0, j = 0; i < innerInstantiatedType.TypeParameters.Count && j < innerInstantiatedType.TypeParameters.Count; i++, j++)
{
if (curType.TypeParameters [i].Name == innerInstantiatedType.TypeParameters [j].Name)
{
innerInstantiatedType.typeParameters.RemoveAt(j);
j--;
}
}
result.Add(innerInstantiatedType);
CreateInstantiatedSubtypes(innerInstantiatedType, innerType, newArguments, resolver);
foreach (int i in removeInheritedArguments)
{
if (i >= 0 && i < newArguments.Count)
{
newArguments.RemoveAt(i);
}
}
}
}
