public override string ToString()
{
if (this.DeclaringType == null)
{
return(string.Concat(m_eventType.ToString(), ' ', this.Name));
}
return(string.Concat(m_eventType.ToString(), ' ',
this.DeclaringType.ToString(), "::", this.Name));
}
public override string ToString()
{
StringBuilder sb = new StringBuilder();
sb.Append(m_propertyType.ToString());
sb.Append(' ');
if (this.DeclaringType != null)
{
sb.Append(this.DeclaringType.ToString());
sb.Append("::");
}
sb.Append(this.Name);
sb.Append('(');
IParameterDefinitionCollection parameters = this.Parameters;
for (int i = 0; i < parameters.Count; i++)
{
if (i > 0)
{
sb.Append(',');
}
sb.Append(parameters [i].ParameterType.ToString());
}
sb.Append(')');
return(sb.ToString());
}
/// <summary>
/// Determine type from field
/// </summary>
/// <param name="typeRef">The type reference.</param>
/// <returns>The type.</returns>
public static int DetermineType(TypeReference typeRef)
{
string type = typeRef.ToString();
// Pointer
if (type.Contains("*"))
return Types.TYPE_OBJ;
if (type == "System.UInt64" || type == "System.Int64")
return Types.TYPE_INT64;
else if (type == "System.Byte" || type == "System.SByte" || type == "System.UInt16" || type == "System.Int16" || type == "System.UInt32" || type == "System.Int32" || type == "System.Boolean")
return Types.TYPE_INT32;
else if (type == "System.Single")
return Types.TYPE_FLOAT;
else if (type == "System.Double")
return Types.TYPE_DOUBLE;
else if (type == "System.Char")
return Types.TYPE_INT32;
else if (type == "System.UIntPtr" || type == "System.IntPtr")
return Types.TYPE_INT32;
return Types.TYPE_OBJ;
}
private static TypeDefinition TryLookUpTypeDefinition(TypeReference reference)
{
// try find in the current assembly
foreach (TypeDefinition tempTypeDef in reference.Module.Types)
if (tempTypeDef.ToString() == reference.ToString())
return tempTypeDef;
return null;
}
/// <summary>
/// Create a SharpDevelop return type from a Cecil type reference.
/// </summary>
internal static IReturnType CreateType(IProjectContent pc, IEntity member, TypeReference type)
{
while (type is TypeSpecification)
{
type = (type as TypeSpecification).ElementType;
}
if (type == null)
{
LoggingService.Warn("CecilReader: Null type for: " + member);
return new VoidReturnType(pc);
}
if (type is ByReferenceType)
{
// TODO: Use ByRefRefReturnType
return CreateType(pc, member, (type as ByReferenceType).ElementType);
} else if (type is PointerType)
{
return new PointerReturnType(CreateType(pc, member, (type as PointerType).ElementType));
} else if (type is ArrayType)
{
return new ArrayReturnType(pc, CreateType(pc, member, (type as ArrayType).ElementType), (type as ArrayType).Rank);
} else if (type is GenericInstanceType)
{
GenericInstanceType gType = (GenericInstanceType)type;
IReturnType[] para = new IReturnType[gType.GenericArguments.Count];
for (int i = 0; i < para.Length; ++i)
{
para[i] = CreateType(pc, member, gType.GenericArguments[i]);
}
return new ConstructedReturnType(CreateType(pc, member, gType.ElementType), para);
} else if (type is GenericParameter)
{
GenericParameter typeGP = type as GenericParameter;
if (typeGP.Owner is MethodDefinition)
{
IMethod method = member as IMethod;
if (method != null)
{
if (typeGP.Position < method.TypeParameters.Count)
{
return new GenericReturnType(method.TypeParameters[typeGP.Position]);
}
}
return new GenericReturnType(new DefaultTypeParameter(method, typeGP.Name, typeGP.Position));
} else {
IClass c = (member is IClass) ? (IClass)member : (member is IMember) ? ((IMember)member).DeclaringType : null;
if (c != null && typeGP.Position < c.TypeParameters.Count) {
if (c.TypeParameters[typeGP.Position].Name == type.Name) {
return new GenericReturnType(c.TypeParameters[typeGP.Position]);
}
}
return new GenericReturnType(new DefaultTypeParameter(c, typeGP.Name, typeGP.Position));
}
} else {
string name = type.FullName;
if (name == null)
throw new ApplicationException("type.FullName returned null. Type: " + type.ToString());
int typeParameterCount;
if (name.IndexOf('/') > 0) {
typeParameterCount = 0;
StringBuilder newName = new StringBuilder();
foreach (string namepart in name.Split('/')) {
if (newName.Length > 0)
newName.Append('.');
int partTypeParameterCount;
newName.Append(ReflectionClass.SplitTypeParameterCountFromReflectionName(namepart, out partTypeParameterCount));
typeParameterCount += partTypeParameterCount;
}
name = newName.ToString();
} else {
name = ReflectionClass.SplitTypeParameterCountFromReflectionName(name, out typeParameterCount);
}
IClass c = pc.GetClass(name, typeParameterCount);
if (c != null) {
return c.DefaultReturnType;
} else {
// 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);
}
}
}
/// <summary>
/// Create a SharpDevelop return type from a Cecil type reference.
/// </summary>
internal static IReturnType CreateType(IProjectContent pc, IDecoration member, TypeReference type)
{
while (type is ModType) {
type = (type as ModType).ElementType;
}
if (type == null) {
LoggingService.Warn("CecilReader: Null type for: " + member);
return VoidReturnType.Instance;
}
if (type is ReferenceType) {
// TODO: Use ByRefRefReturnType
return CreateType(pc, member, (type as ReferenceType).ElementType);
} else if (type is ArrayType) {
return new ArrayReturnType(pc, CreateType(pc, member, (type as ArrayType).ElementType), (type as ArrayType).Rank);
} else if (type is GenericInstanceType) {
GenericInstanceType gType = (GenericInstanceType)type;
IReturnType[] para = new IReturnType[gType.GenericArguments.Count];
for (int i = 0; i < para.Length; ++i) {
para[i] = CreateType(pc, member, gType.GenericArguments[i]);
}
return new ConstructedReturnType(CreateType(pc, member, gType.ElementType), para);
} else if (type is GenericParameter) {
GenericParameter typeGP = type as GenericParameter;
if (typeGP.Owner is MethodDefinition) {
IMethod method = member as IMethod;
if (method != null) {
if (typeGP.Position < method.TypeParameters.Count) {
return new GenericReturnType(method.TypeParameters[typeGP.Position]);
}
}
return new GenericReturnType(new DefaultTypeParameter(method, typeGP.Name, typeGP.Position));
} else {
IClass c = (member is IClass) ? (IClass)member : (member is IMember) ? ((IMember)member).DeclaringType : null;
if (c != null && typeGP.Position < c.TypeParameters.Count) {
if (c.TypeParameters[typeGP.Position].Name == type.Name) {
return new GenericReturnType(c.TypeParameters[typeGP.Position]);
}
}
return new GenericReturnType(new DefaultTypeParameter(c, typeGP.Name, typeGP.Position));
}
} else {
string name = type.FullName;
if (name == null)
throw new ApplicationException("type.FullName returned null. Type: " + type.ToString());
if (name.IndexOf('/') > 0) {
name = name.Replace('/', '.');
}
int typeParameterCount = 0;
if (name.Length > 2 && name[name.Length - 2] == '`') {
typeParameterCount = name[name.Length - 1] - '0';
name = name.Substring(0, name.Length - 2);
}
IClass c = pc.GetClass(name, typeParameterCount);
if (c != null) {
return c.DefaultReturnType;
} else {
// 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);
}
}
}
static bool TypeMatch (TypeReference a, TypeReference b, ref Dictionary<string,string> gp)
{
var gpa = a as GenericParameter;
if (gpa != null) {
if (gp == null)
gp = new Dictionary<string, string> ();
string match;
if (!gp.TryGetValue (gpa.FullName, out match)) {
// first use, we assume it will always be used this way
gp.Add (gpa.FullName, b.ToString ());
return true;
}
// re-use, it should match the previous usage
return match == b.ToString ();
}
if (a is TypeSpecification || b is TypeSpecification) {
if (a.GetType () != b.GetType ())
return false;
return TypeMatch ((TypeSpecification) a, (TypeSpecification) b, ref gp);
}
return a.FullName == b.FullName;
}
XNodeOut GetClassRef(TypeReference declaringType)
{
//if(!declaringType.IsGenericParameter && !declaringType.IsFunctionPointer)
// XDef.ParseAndCheck(declaringType.ToString());
if (declaringType.IsGenericParameter)
Debug.WriteLine("GetClassRef for Generic Param - " + declaringType.ToString());
if (declaringType.IsFunctionPointer)
Debug.WriteLine("GetClassRef for Function Pointer - " + declaringType.ToString());
var scope = declaringType.Scope;
if (scope.MetadataScopeType == MetadataScopeType.ModuleReference)
{
// is this scope type internal or external, should it be tracked externally?
Debug.WriteLine("Skipped GetClassRef for - " + declaringType.ToString());
Debug.Assert(false);
return null;
}
//string namespaces = (declaringType.DeclaringType != null) ? declaringType.DeclaringType.Namespace : declaringType.Namespace;
//string className = declaringType.Name;
XNodeOut fileNode = null;
// if xrayed internal
if (scope.MetadataScopeType == MetadataScopeType.ModuleDefinition)
fileNode = XFile.FileNode;
// xrayed, but in diff module
else if (Build.Files.Any(f => f.AssemblyName == scope.Name))
fileNode = Build.Files.First(f => f.AssemblyName == scope.Name).FileNode;
// if not xrayed - map to external root
else
{
string moduleName = scope.Name;
fileNode = ExtRoot.AddNode(moduleName, XObjType.File);
}
return SignatureToClass(declaringType.ToString(), fileNode);
}
ITypeReference CreateType(
TypeReference type,
IEntity entity,
ICustomAttributeProvider typeAttributes, ref int typeIndex)
{
while (type is OptionalModifierType || type is RequiredModifierType) {
type = ((TypeSpecification)type).ElementType;
}
if (type == null) {
return SharedTypes.UnknownType;
}
if (type is Mono.Cecil.ByReferenceType) {
typeIndex++;
return ByReferenceTypeReference.Create(
CreateType(
(type as Mono.Cecil.ByReferenceType).ElementType,
entity, typeAttributes, ref typeIndex));
} else if (type is Mono.Cecil.PointerType) {
typeIndex++;
return PointerTypeReference.Create(
CreateType(
(type as Mono.Cecil.PointerType).ElementType,
entity, typeAttributes, ref typeIndex));
} else if (type is Mono.Cecil.ArrayType) {
typeIndex++;
return ArrayTypeReference.Create(
CreateType(
(type as Mono.Cecil.ArrayType).ElementType,
entity, typeAttributes, ref typeIndex),
(type as Mono.Cecil.ArrayType).Rank);
} else if (type is GenericInstanceType) {
GenericInstanceType gType = (GenericInstanceType)type;
ITypeReference baseType = CreateType(gType.ElementType, entity, typeAttributes, ref typeIndex);
ITypeReference[] para = new ITypeReference[gType.GenericArguments.Count];
for (int i = 0; i < para.Length; ++i) {
typeIndex++;
para[i] = CreateType(gType.GenericArguments[i], entity, typeAttributes, ref typeIndex);
}
return ParameterizedTypeReference.Create(baseType, para);
} else if (type is GenericParameter) {
GenericParameter typeGP = type as GenericParameter;
if (typeGP.Owner is MethodDefinition) {
IMethod method = entity as IMethod;
if (method != null) {
if (typeGP.Position < method.TypeParameters.Count) {
return method.TypeParameters[typeGP.Position];
}
}
return SharedTypes.UnknownType;
} else {
ITypeDefinition c = (entity as ITypeDefinition) ?? (entity is IMember ? ((IMember)entity).DeclaringTypeDefinition : null);
if (c != null && typeGP.Position < c.TypeParameters.Count) {
if (c.TypeParameters[typeGP.Position].Name == type.Name) {
return c.TypeParameters[typeGP.Position];
}
}
return SharedTypes.UnknownType;
}
} else if (type.IsNested) {
ITypeReference typeRef = CreateType(type.DeclaringType, entity, typeAttributes, ref typeIndex);
int partTypeParameterCount;
string namepart = ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name, out partTypeParameterCount);
return new NestedTypeReference(typeRef, namepart, partTypeParameterCount);
} else {
string ns = type.Namespace ?? string.Empty;
string name = type.Name;
if (name == null)
throw new InvalidOperationException("type.Name returned null. Type: " + type.ToString());
if (name == "Object" && ns == "System" && HasDynamicAttribute(typeAttributes, typeIndex)) {
return SharedTypes.Dynamic;
} else {
int typeParameterCount;
name = ReflectionHelper.SplitTypeParameterCountFromReflectionName(name, out typeParameterCount);
var earlyBindContext = this.EarlyBindContext;
if (earlyBindContext != null) {
IType c = earlyBindContext.GetClass(ns, name, typeParameterCount, StringComparer.Ordinal);
if (c != null)
return c;
}
return new GetClassTypeReference(ns, name, typeParameterCount);
}
}
}
static AstType ConvertType(TypeReference type, ICustomAttributeProvider typeAttributes, ref int typeIndex)
{
while (type is OptionalModifierType || type is RequiredModifierType) {
type = ((TypeSpecification)type).ElementType;
}
if (type == null) {
return AstType.Null;
}
if (type is Mono.Cecil.ByReferenceType) {
typeIndex++;
// ignore by reference type (cannot be represented in C#)
return ConvertType((type as Mono.Cecil.ByReferenceType).ElementType, typeAttributes, ref typeIndex);
} else if (type is Mono.Cecil.PointerType) {
typeIndex++;
return ConvertType((type as Mono.Cecil.PointerType).ElementType, typeAttributes, ref typeIndex)
.MakePointerType();
} else if (type is Mono.Cecil.ArrayType) {
typeIndex++;
return ConvertType((type as Mono.Cecil.ArrayType).ElementType, typeAttributes, ref typeIndex)
.MakeArrayType((type as Mono.Cecil.ArrayType).Rank);
} else if (type is GenericInstanceType) {
GenericInstanceType gType = (GenericInstanceType)type;
if (gType.ElementType.Namespace == "System" && gType.ElementType.Name == "Nullable`1" && gType.GenericArguments.Count == 1) {
typeIndex++;
return new ComposedType {
BaseType = ConvertType(gType.GenericArguments[0], typeAttributes, ref typeIndex),
HasNullableSpecifier = true
};
}
AstType baseType = ConvertType(gType.ElementType, typeAttributes, ref typeIndex);
List<AstType> typeArguments = new List<AstType>();
foreach (var typeArgument in gType.GenericArguments) {
typeIndex++;
typeArguments.Add(ConvertType(typeArgument, typeAttributes, ref typeIndex));
}
ApplyTypeArgumentsTo(baseType, typeArguments);
return baseType;
} else if (type is GenericParameter) {
return new SimpleType(type.Name);
} else if (type.IsNested) {
AstType typeRef = ConvertType(type.DeclaringType, typeAttributes, ref typeIndex);
string namepart = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name);
return new MemberType { Target = typeRef, MemberName = namepart }.WithAnnotation(type);
} else {
string ns = type.Namespace ?? string.Empty;
string name = type.Name;
if (name == null)
throw new InvalidOperationException("type.Name returned null. Type: " + type.ToString());
if (name == "Object" && ns == "System" && HasDynamicAttribute(typeAttributes, typeIndex)) {
return new PrimitiveType("dynamic");
} else {
if (ns == "System") {
switch (name) {
case "SByte":
return new PrimitiveType("sbyte");
case "Int16":
return new PrimitiveType("short");
case "Int32":
return new PrimitiveType("int");
case "Int64":
return new PrimitiveType("long");
case "Byte":
return new PrimitiveType("byte");
case "UInt16":
return new PrimitiveType("ushort");
case "UInt32":
return new PrimitiveType("uint");
case "UInt64":
return new PrimitiveType("ulong");
case "String":
return new PrimitiveType("string");
case "Single":
return new PrimitiveType("float");
case "Double":
return new PrimitiveType("double");
case "Decimal":
return new PrimitiveType("decimal");
case "Char":
return new PrimitiveType("char");
case "Boolean":
return new PrimitiveType("bool");
case "Void":
return new PrimitiveType("void");
case "Object":
return new PrimitiveType("object");
}
}
name = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.SplitTypeParameterCountFromReflectionName(name);
// TODO: Until we can simplify type with 'using', use just the name without namesapce
return new SimpleType(name).WithAnnotation(type);
// if (ns.Length == 0)
// return new SimpleType(name).WithAnnotation(type);
// string[] parts = ns.Split('.');
// AstType nsType = new SimpleType(parts[0]);
// for (int i = 1; i < parts.Length; i++) {
// nsType = new MemberType { Target = nsType, MemberName = parts[i] };
// }
// return new MemberType { Target = nsType, MemberName = name }.WithAnnotation(type);
}
}
}
private TypeReference ReferenceTypeSpecification(TypeReference type, params IGenericParameterProvider[] paramProviders)
{
if (type.IsRequiredModifier)
{
var requiredModifier = (RequiredModifierType)type;
var modifierType = ReferenceType(requiredModifier.ModifierType, paramProviders);
return ReferenceType(requiredModifier.ElementType, paramProviders).MakeRequiredModifierType(modifierType);
}
else if (type.IsByReference)
{
return ReferenceType(((ByReferenceType)type).ElementType, paramProviders).MakeByReferenceType();
}
else if (type.IsArray)
{
var array = (ArrayType)type;
return ReferenceType(array.ElementType, paramProviders).MakeArrayType(array.Rank);
}
else if (type.IsGenericInstance)
{
var genericInstance = (GenericInstanceType)type;
var elementType = ReferenceType(genericInstance.ElementType, paramProviders);
return ReferenceGenericInstanceType(genericInstance, elementType, paramProviders);
}
//TODO PointerType, PinnedType, SentinelType, OptionalModifierType, SzArray ?
else
{
throw new NotSupportedException(type.ToString());
}
}
internal Class GetClass (TypeReference type)
{
if (type is GenericParameter
&& this.genericInstanceType != null) {
GenericParameter genericParameter = type as GenericParameter;
int i = 0;
for (; i < genericParameter.Owner.GenericParameters.Count; i++) {
if (genericParameter.Owner.GenericParameters [i].FullName == genericParameter.FullName)
break;
}
if (i >= genericParameter.Owner.GenericParameters.Count)
throw new EngineException (string.Format ("Type '{0}' was not found in the method '{1}'.", type.ToString (), this.TypeFullName));
type = this.genericInstanceType.GenericArguments [i];
} else if (type is GenericInstanceType
&& (type as GenericInstanceType).GenericArguments [0] is GenericParameter) {
GenericInstanceType _genericInstanceType = new GenericInstanceType ((type as GenericInstanceType).ElementType);
for (int i = 0; i < (type as GenericInstanceType).GenericArguments.Count; i++)
_genericInstanceType.GenericArguments.Add (this.genericInstanceType.GenericArguments [i]);
return this.GetClass (_genericInstanceType);
}
return this.engine.GetClass (type);
}
private ImportedType ImportType(TypeReference tref)
{
if (tref == null) return null;
switch (tref.MetadataType)
{
case MetadataType.Pointer:
case MetadataType.Pinned:
case MetadataType.Array:
ImportType(tref.GetElementType());
return null;
case MetadataType.OptionalModifier:
case MetadataType.RequiredModifier:
case MetadataType.ByReference:
return ImportType(tref.GetElementType());
case MetadataType.Boolean:
case MetadataType.Byte:
case MetadataType.Char:
case MetadataType.Double:
case MetadataType.FunctionPointer:
case MetadataType.GenericInstance:
case MetadataType.Int16:
case MetadataType.Int32:
case MetadataType.Int64:
case MetadataType.IntPtr:
case MetadataType.MVar:
case MetadataType.Object:
case MetadataType.SByte:
case MetadataType.Single:
case MetadataType.String:
case MetadataType.UInt16:
case MetadataType.UInt32:
case MetadataType.UInt64:
case MetadataType.UIntPtr:
case MetadataType.ValueType:
case MetadataType.Var:
case MetadataType.Void:
case MetadataType.TypedByReference:
return null;
}
if (tref is GenericInstanceType)
{
GenericInstanceType gt = (GenericInstanceType)tref;
for (int i = 0; i < gt.GenericArguments.Count; i++)
ImportType(gt.GenericArguments[i]);
if (gt.ElementType is TypeDefinition) return null;
tref = gt.ElementType;
}
if (tref is TypeDefinition) return null;
if (typeCache.ContainsKey(tref)) return typeCache[tref];
if (Program.IsFiltered(tref)) return null;
var mod = output.library.Where(a => a.name == tref.Scope.Name).FirstOrDefault();
if (mod == null)
{
mod = new ImportedLibrary();
mod.name = tref.Scope.Name;
mod.fullname = tref.Module.AssemblyReferences.Where(a => a.Name == tref.Scope.Name).FirstOrDefault().FullName;
output.library.Add(mod);
}
var it = new ImportedType();
it.name = tref.ToString();
mod.type.Add(it);
typeCache.Add(tref, it);
return it;
}
string StringifyTypeRef (TypeReference t) {
switch (t.MetadataType) {
case MetadataType.Void:
return "void";
case MetadataType.Boolean:
return "bool";
case MetadataType.Char:
return "char";
case MetadataType.SByte:
return "int8";
case MetadataType.Byte:
return "unsigned int8";
case MetadataType.Int16:
return "int16";
case MetadataType.UInt16:
return "unsigned int16";
case MetadataType.Int32:
return "int32";
case MetadataType.UInt32:
return "unsigned int32";
case MetadataType.Int64:
return "int64";
case MetadataType.UInt64:
return "unsigned int64";
case MetadataType.Single:
return "float32";
case MetadataType.Double:
return "float64";
case MetadataType.String:
return "string";
case MetadataType.IntPtr:
return "native int";
case MetadataType.UIntPtr:
//return "unsigned native int";
return "[mscorlib]System.UIntPtr";
case MetadataType.TypedByReference:
return "typedref";
case MetadataType.Class:
case MetadataType.Object:
case MetadataType.ValueType: {
var sb = new StringBuilder ();
IMetadataScope s = t.Scope;
if (t.MetadataType == MetadataType.ValueType)
sb.Append ("valuetype ");
else
sb.Append ("class ");
EmitScope (s, sb);
sb.Append (EscapeName (t.FullName));
return sb.ToString ();
}
case MetadataType.Array: {
ArrayType at = (t as ArrayType);
if (at.IsVector)
return StringifyTypeRef (at.ElementType) + "[]";
var suffix = new StringBuilder ();
suffix.Append ("[");
for (int i = 0; i < at.Dimensions.Count; i++) {
if (i > 0)
suffix.Append (",");
suffix.Append (at.Dimensions [i].ToString ());
}
suffix.Append ("]");
return StringifyTypeRef (at.ElementType) + suffix;
}
case MetadataType.Pointer:
return StringifyTypeRef ((t as TypeSpecification).ElementType) + "*";
case MetadataType.ByReference:
return StringifyTypeRef ((t as TypeSpecification).ElementType) + "&";
case MetadataType.Pinned:
return StringifyTypeRef ((t as TypeSpecification).ElementType) + " pinned";
case MetadataType.GenericInstance: {
var sb = new StringBuilder ();
var inst = (t as GenericInstanceType);
sb.Append (StringifyTypeRef (inst.ElementType));
sb.Append ("<");
int aindex = 0;
foreach (TypeReference arg in inst.GenericArguments) {
if (aindex > 0)
sb.Append (", ");
sb.Append (StringifyTypeRef (arg));
aindex ++;
}
sb.Append (">");
return sb.ToString ();
}
case MetadataType.Var:
return "!" + (t as GenericParameter).Position;
case MetadataType.MVar:
return "!!" + (t as GenericParameter).Position;
case MetadataType.Sentinel:
return "..., " + StringifyTypeRef ((t as SentinelType).ElementType);
case MetadataType.RequiredModifier: {
var mod = (t as RequiredModifierType);
if (mod.ModifierType.MetadataType != MetadataType.Class)
throw new NotImplementedException ();
var sb = new StringBuilder ();
sb.Append (StringifyTypeRef (mod.ElementType));
sb.Append (" modreq (");
EmitScope (mod.ModifierType.Scope, sb);
sb.Append (EscapeName (mod.ModifierType.FullName));
sb.Append (")");
return sb.ToString ();
}
default:
throw new NotImplementedException ("" + t.MetadataType + " " + t.ToString ());
}
}
/// <summary>
/// Elements the specified type definition.
/// </summary>
/// <param name="typeDefinition">The type definition.</param>
public void Element (TypeReference typeDefinition)
{
this.AddElement ("type", typeDefinition.ToString ());
}