public InstantiatedParameterType(ProjectDom dom, ITypeParameterMember typeParameterMember, ITypeParameter tp)
{
IType outerType = typeParameterMember as IType ?? typeParameterMember.DeclaringType;
typeparam = tp;
compilationUnit = outerType.CompilationUnit;
ClassType = ClassType.Class;
Modifiers = Modifiers.Public;
Name = tp.Name;
Namespace = outerType.DecoratedFullName;
Location = outerType.Location;
DeclaringType = outerType;
if (tp.ValueTypeRequired)
{
BaseType = new DomReturnType("System.ValueType");
}
if (tp.Constraints.Count > 0)
{
ClassType = ClassType.Interface;
}
foreach (IReturnType rt in tp.Constraints)
{
if (FindCyclicReference(new HashSet <ITypeParameter> ()
{
tp
}, outerType, ((DomReturnType)rt).DecoratedFullName))
{
continue;
}
IType bt = dom.SearchType(typeParameterMember, rt);
IReturnType resolvedType = rt;
if (bt != null)
{
resolvedType = new DomReturnType(bt);
if (bt.ClassType == ClassType.Interface || BaseType != null)
{
AddInterfaceImplementation(resolvedType);
}
else
{
ClassType = bt.ClassType;
BaseType = resolvedType;
}
}
else
{
AddInterfaceImplementation(resolvedType);
}
}
if (BaseType == null)
{
BaseType = DomReturnType.Object;
}
}
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 override INode Visit(IReturnType type, IType typeToInstantiate)
{
DomReturnType copyFrom = (DomReturnType)type;
string decoratedName = copyFrom.DecoratedFullName;
IReturnType result = LookupReturnType(decoratedName, type, typeToInstantiate);
IType curType = currentType;
while (result == null && curType != null)
{
result = LookupReturnType(curType.DecoratedFullName + "." + decoratedName, type, typeToInstantiate);
curType = curType.DeclaringType;
}
return(result ?? base.Visit(type, typeToInstantiate));
}
public override INode Visit(IReturnType type, object data)
{
IReturnType rt = (IReturnType)base.Visit(type, data);
if (BuiltInTypes.Contains(rt.FullName))
{
return(rt);
}
DomReturnType returnType = new DomReturnType(rt);
string longest = "";
string lastAlias = null;
if (callingType != null && returnType.DecoratedFullName.StartsWith(callingType.FullName))
{
int p1 = System.Math.Min(callingType.FullName.Count(ch => ch == '.') + 1, returnType.Parts.Count - 1);
returnType.Parts.RemoveRange(0, p1);
returnType.Namespace = "";
return(returnType);
}
foreach (IUsing u in unit.Usings.Where(u => u.ValidRegion.Contains(location)))
{
foreach (string ns in u.Namespaces.Where(ns => returnType.Namespace == ns || returnType.Namespace != null && returnType.Namespace.StartsWith(ns + ".")))
{
if (longest.Length < ns.Length)
{
longest = ns;
}
}
foreach (KeyValuePair <string, IReturnType> alias in u.Aliases)
{
if (alias.Value.ToInvariantString() == type.ToInvariantString())
{
lastAlias = alias.Key;
}
}
}
if (lastAlias != null)
{
return(new DomReturnType(lastAlias));
}
if (longest.Length > 0 && returnType.Namespace == longest)
{
returnType.Namespace = "";
}
return(returnType);
}
public virtual INode Visit(IReturnType type, T data)
{
List <IReturnTypePart> parts = new List <IReturnTypePart> (type.Parts.Count);
foreach (IReturnTypePart part in type.Parts)
{
parts.Add((IReturnTypePart)Visit(part, data));
}
DomReturnType rt = new DomReturnType(type.Namespace, parts);
rt.PointerNestingLevel = type.PointerNestingLevel;
rt.IsNullable = type.IsNullable;
rt.SetDimensions(type.GetDimensions());
rt.Type = type.Type; // for anonymous types
return(rt);
}
IReturnType LookupReturnType(string decoratedName, IReturnType type, IType typeToInstantiate)
{
IReturnType res;
if (typeTable.TryGetValue(decoratedName, out res))
{
if (type.ArrayDimensions == 0 && type.PointerNestingLevel == 0)
{
return(res);
}
DomReturnType copy = (DomReturnType)base.Visit(res, typeToInstantiate);
copy.PointerNestingLevel = type.PointerNestingLevel;
copy.SetDimensions(type.GetDimensions());
return(copy);
}
return(null);
}
void CheckReturnType(IReturnType type)
{
if (type == null)
{
return;
}
IType resultType;
if (argTypes.TryGetValue(type.FullName, out resultType))
{
DomReturnType returnType = (DomReturnType)type;
// Console.Write ("Convert:" + returnType);
string returnTypeName = returnType.FullName;
returnType.SetType(resultType);
returnType.Parts.Add(new ReturnTypePart(returnTypeName, null));
// Console.WriteLine (" to:" + returnType);
}
}
public DomReturnType(IReturnType type)
{
DomReturnType rt = (DomReturnType)type;
if (rt.dimensions != null)
{
dimensions = new int [rt.dimensions.Length];
rt.dimensions.CopyTo(dimensions, 0);
}
IsGenerated = rt.IsGenerated;
nspace = rt.nspace;
pointerNestingLevel = rt.pointerNestingLevel;
arrayPointerNestingLevel = rt.arrayPointerNestingLevel;
modifiers = rt.modifiers;
foreach (var p in rt.Parts)
{
parts.Add(new ReturnTypePart(p));
}
}
public static string GetInstantiatedTypeName(string typeName, IList <IReturnType> genericArguments)
{
if (genericArguments == null || genericArguments.Count == 0)
{
return(typeName);
}
StringBuilder sb = new StringBuilder(typeName);
sb.Append('[');
for (int i = 0; i < genericArguments.Count; i++)
{
if (i > 0)
{
sb.Append(',');
}
sb.Append(DomReturnType.ConvertToString(genericArguments [i]));
}
sb.Append(']');
return(sb.ToString());
}
internal static void AddType(ProjectDom dom, List <object> result, IReturnType returnType, IMember callingMember, bool showStatic)
{
if (returnType == null || returnType.FullName == "System.Void")
{
return;
}
if (returnType.ArrayDimensions > 0)
{
DomReturnType elementType = new DomReturnType(returnType.FullName);
elementType.ArrayDimensions = returnType.ArrayDimensions - 1;
for (int i = 0; i < elementType.ArrayDimensions; i++)
{
elementType.SetDimension(i, returnType.ArrayDimensions - 1);
}
elementType.PointerNestingLevel = returnType.PointerNestingLevel;
AddType(dom, result, dom.GetArrayType(elementType), callingMember, showStatic);
return;
}
IType type = dom.GetType(returnType);
AddType(dom, result, type, callingMember, showStatic);
}
public override INode Visit(IReturnType type, IMethod typeToInstantiate)
{
DomReturnType copyFrom = (DomReturnType)type;
IReturnType res;
if (typeTable.TryGetValue(copyFrom.DecoratedFullName, out res))
{
if (type.ArrayDimensions > 0)
{
DomReturnType drr = new DomReturnType(res.FullName);
drr.PointerNestingLevel = type.PointerNestingLevel;
drr.ArrayDimensions = type.ArrayDimensions;
drr.Type = type.Type; // May be anonymous type
for (int i = 0; i < type.ArrayDimensions; i++)
{
drr.SetDimension(i, type.GetDimension(i));
}
return(drr);
}
return(res);
}
return(base.Visit(type, typeToInstantiate));
}
public void Add(ProjectDom dom, IReturnType parameterType, IReturnType type)
{
// Console.WriteLine ("Add:" + parameterType +"\n\t->" + type);
if (type == null || string.IsNullOrEmpty(type.FullName))
{
return;
}
string name = parameterType.Name;
bool contains = typeTable.ContainsKey(name);
// when the type is already in the table use the type that is more general in the inheritance tree.
if (contains && dom != null)
{
var t1 = dom.GetType(typeTable[name]);
var t2 = dom.GetType(type);
if (t1 != null && !dom.GetInheritanceTree(t1).Any(t => t.DecoratedFullName == t2.DecoratedFullName))
{
return;
}
}
DomReturnType newType = new DomReturnType(type.FullName);
newType.ArrayDimensions = Math.Max(0, type.ArrayDimensions - parameterType.ArrayDimensions);
newType.PointerNestingLevel = Math.Max(0, type.PointerNestingLevel - parameterType.PointerNestingLevel);
newType.Type = type.Type; // May be anonymous type
for (int i = 0; i < newType.ArrayDimensions; i++)
{
newType.SetDimension(i, parameterType.GetDimension(i));
}
foreach (var generic in type.GenericArguments)
{
newType.AddTypeParameter(generic);
}
typeTable[name] = newType;
}
public override bool Equals(object obj)
{
DomReturnType type = obj as DomReturnType;
if (type == null)
{
return(false);
}
if (ArrayDimensions != type.ArrayDimensions)
{
return(false);
}
for (int n = 0; n < ArrayDimensions; n++)
{
if (GetDimension(n) != type.GetDimension(n))
{
return(false);
}
}
if (GenericArguments.Count != type.GenericArguments.Count)
{
return(false);
}
for (int i = 0; i < GenericArguments.Count; i++)
{
if (!GenericArguments[i].Equals(type.GenericArguments [i]))
{
return(false);
}
}
return(Name == type.Name &&
nspace == type.nspace &&
pointerNestingLevel == type.pointerNestingLevel &&
Modifiers == type.Modifiers);
}
/*
* // Check if 'type' has some decorations applied to it
* if (type is Mono.Cecil.TypeSpecification) {
* // Go through all levels of 'indirection', 'array dimensions'
* // and 'generic types' - in the end, we should get the actual
* // type of the ReturnType (but all data about its array
* // dimensions, levels of indirection and even its generic
* // parameters is correctly stored within ArrayCount and
* // ArrayDimensions, PointerNestingLevel and GenericArguments
* // respectively).
* if (type is ArrayType) {
* // This return type is obviously an array - add the rank
* ArrayType at = (ArrayType) type;
* if (arrays == null)
* arrays = new Stack<int>();
* arrays.Push(at.Rank);
* type = at.ElementType;
* } else else if (type is Mono.Cecil.ReferenceType) {
* Mono.Cecil.ReferenceType rt = (Mono.Cecil.ReferenceType) type;
* byRef = true;
* type = rt.ElementType;
* } else if (type is PointerType) {
* // The type is a pointer
* PointerType pt = (PointerType) type;
++pointerNestingLevel;
* type = pt.ElementType;
* // Go down one level
* } else {
* // TODO: Check if we loose some relevant info here
* type = ((TypeSpecification)type).ElementType;
* }*/
public static DomReturnType GetReturnType(TypeReference typeReference)
{
if (typeReference == null)
{
return(new DomReturnType(DomReturnType.Void.ToInvariantString()));
}
if (typeReference is Mono.Cecil.GenericInstanceType)
{
Mono.Cecil.GenericInstanceType genType = (Mono.Cecil.GenericInstanceType)typeReference;
DomReturnType result = GetReturnType(genType.ElementType);
foreach (TypeReference typeRef in genType.GenericArguments)
{
DomReturnType param = GetReturnType(typeRef);
foreach (IReturnTypePart part in result.Parts)
{
if (part.Tag is TypeDefinition)
{
TypeDefinition typeDef = (TypeDefinition)part.Tag;
foreach (TypeReference typeParam in typeDef.GenericParameters)
{
if (typeParam.Name == param.Name)
{
part.AddTypeParameter(param);
goto skip;
}
}
}
}
result.AddTypeParameter(param);
skip :;
}
return(result);
}
if (typeReference is Mono.Cecil.ArrayType)
{
Mono.Cecil.ArrayType arrType = (Mono.Cecil.ArrayType)typeReference;
DomReturnType result = GetReturnType(arrType.ElementType);
result.ArrayDimensions++;
result.SetDimension(result.ArrayDimensions - 1, arrType.Rank - 1);
return(result);
}
if (typeReference is Mono.Cecil.PointerType)
{
Mono.Cecil.PointerType ptrType = (Mono.Cecil.PointerType)typeReference;
DomReturnType result = GetReturnType(ptrType.ElementType);
if (result.ArrayDimensions > 0)
{
result.ArrayPointerNestingLevel++;
}
else
{
result.PointerNestingLevel++;
}
return(result);
}
if (typeReference is Mono.Cecil.ByReferenceType)
{
return(GetReturnType(((Mono.Cecil.ByReferenceType)typeReference).ElementType));
}
if (typeReference is Mono.Cecil.TypeDefinition)
{
Mono.Cecil.TypeDefinition typeDefinition = (Mono.Cecil.TypeDefinition)typeReference;
DomReturnType result;
if (typeDefinition.DeclaringType != null)
{
result = GetReturnType(typeDefinition.DeclaringType);
result.Parts.Add(new ReturnTypePart(typeDefinition.Name));
result.Tag = typeDefinition;
}
else
{
result = new DomReturnType(typeDefinition.Name);
result.Namespace = typeDefinition.Namespace;
result.Tag = typeDefinition;
}
return(result);
}
return(new DomReturnType(DomCecilType.RemoveGenericParamSuffix(typeReference.FullName)));
}
public ExtensionMethod(IType extensionType, IMethod originalMethod, IList <IReturnType> genericArguments, IEnumerable <IReturnType> methodArguments)
{
if (extensionType == null)
{
throw new ArgumentNullException("extensionType");
}
if (originalMethod == null)
{
throw new ArgumentNullException("originalMethod");
}
this.DeclaringType = extensionType;
List <IReturnType> args = new List <IReturnType> ();
if (extensionType.FullName.EndsWith("[]"))
{
foreach (IReturnType returnType in extensionType.BaseTypes)
{
if (returnType.FullName == "System.Collections.Generic.IList" && returnType.GenericArguments.Count > 0)
{
args.Add(returnType.GenericArguments[0]);
break;
}
}
if (args.Count == 0)
{
args.Add(new DomReturnType(extensionType));
}
}
else if (extensionType is InstantiatedType)
{
InstantiatedType instType = (InstantiatedType)extensionType;
DomReturnType uninstantiatedReturnType = new DomReturnType(instType.UninstantiatedType.FullName);
foreach (IReturnType genArg in instType.GenericParameters)
{
uninstantiatedReturnType.AddTypeParameter(genArg);
}
args.Add(uninstantiatedReturnType);
}
else
{
args.Add(new DomReturnType(extensionType));
}
if (methodArguments != null)
{
args.AddRange(methodArguments);
}
// Console.WriteLine ("Create Extension method from:");
// Console.WriteLine ("ext type:" + args[0]);
// Console.WriteLine (originalMethod);
this.method = DomMethod.CreateInstantiatedGenericMethod(originalMethod, genericArguments, args);
// skip first parameter.
for (int i = 1; i < method.Parameters.Count; i++)
{
Add(method.Parameters[i]);
}
foreach (ITypeParameter par in method.TypeParameters)
{
AddTypeParameter(par);
}
this.ExtensionType = extensionType;
this.OriginalMethod = originalMethod;
//Console.WriteLine (this);
//Console.WriteLine ("oOoOoOoOoOoOoOoOoOoOoOoOoOoO");
}
