public override TypeReference Clone() { InnerClassTypeReference c = new InnerClassTypeReference(baseType.Clone(), Type, new List <TypeReference>()); CopyFields(this, c); return(c); }
/// <summary> /// Converts tree into nested TypeReference/InnerClassTypeReference. /// Dotted names are split into separate nodes. /// It does not normalize generic arguments. /// </summary> private static TypeReference NormalizeTypeReference(this INode expr) { if (expr is IdentifierExpression) { return(new TypeReference( ((IdentifierExpression)expr).Identifier, ((IdentifierExpression)expr).TypeArguments )); } else if (expr is MemberReferenceExpression) { TypeReference outter = NormalizeTypeReference(((MemberReferenceExpression)expr).TargetObject); return(new InnerClassTypeReference( outter, ((MemberReferenceExpression)expr).MemberName, ((MemberReferenceExpression)expr).TypeArguments )); } else if (expr is TypeReferenceExpression) { return(NormalizeTypeReference(((TypeReferenceExpression)expr).TypeReference)); } else if (expr is InnerClassTypeReference) { // Frist - it is also TypeReference InnerClassTypeReference typeRef = (InnerClassTypeReference)expr; string[] names = typeRef.Type.Split('.'); TypeReference newRef = NormalizeTypeReference(typeRef.BaseType); foreach (string name in names) { newRef = new InnerClassTypeReference(newRef, name, new List <TypeReference>()); } newRef.GenericTypes.AddRange(typeRef.GenericTypes); newRef.PointerNestingLevel = typeRef.PointerNestingLevel; newRef.RankSpecifier = typeRef.RankSpecifier; return(newRef); } else if (expr is TypeReference) { TypeReference typeRef = (TypeReference)expr; string[] names = typeRef.Type.Split('.'); if (names.Length == 1) { return(typeRef); } TypeReference newRef = null; foreach (string name in names) { if (newRef == null) { newRef = new TypeReference(name, new List <TypeReference>()); } else { newRef = new InnerClassTypeReference(newRef, name, new List <TypeReference>()); } } newRef.GenericTypes.AddRange(typeRef.GenericTypes); newRef.PointerNestingLevel = typeRef.PointerNestingLevel; newRef.RankSpecifier = typeRef.RankSpecifier; return(newRef); } else { throw new EvaluateException(expr, "Type expected. {0} seen.", expr.GetType().FullName); } }
public static TypeReference GetTypeReference(this Type type) { List <int> arrayRanks = new List <int>(); while (type.IsArray) { // C# uses reverse array order arrayRanks.Add(type.GetArrayRank() - 1); type = type.GetElementType(); } int pointerNest = 0; while (type.IsPointer) { pointerNest++; type = type.GetElementType(); } if (type.IsArray) { throw new DebuggerException("C# does not support pointers to arrays"); } string name = type.Name; if (name.IndexOf('`') != -1) { name = name.Substring(0, name.IndexOf('`')); } if (!string.IsNullOrEmpty(type.Namespace)) { name = type.Namespace + "." + name; } List <Type> genArgs = new List <Type>(); // This inludes the generic arguments of the outter types genArgs.AddRange(type.GetGenericArguments()); if (type.DeclaringType != null) { genArgs.RemoveRange(0, type.DeclaringType.GetGenericArguments().Length); } List <TypeReference> genTypeRefs = new List <TypeReference>(); foreach (Type genArg in genArgs) { genTypeRefs.Add(genArg.GetTypeReference()); } if (type.DeclaringType != null) { TypeReference outterRef = type.DeclaringType.GetTypeReference(); InnerClassTypeReference innerRef = new InnerClassTypeReference(outterRef, name, genTypeRefs); innerRef.PointerNestingLevel = pointerNest; innerRef.RankSpecifier = arrayRanks.ToArray(); return(innerRef.SetStaticType((DebugType)type)); } else { return(new TypeReference(name, pointerNest, arrayRanks.ToArray(), genTypeRefs).SetStaticType((DebugType)type)); } }