static AstType ConvertType(TypeReference type, ICustomAttributeProvider typeAttributes, ref int typeIndex, ConvertTypeOptions options) { while (type is OptionalModifierType || type is RequiredModifierType) { type = ((TypeSpecification)type).ElementType; } if (type == null) { return AstType.Null; } if (type is Mono.Cecil.ByReferenceType) { typeIndex++; // by reference type cannot be represented in C#; so we'll represent it as a pointer instead return ConvertType((type as Mono.Cecil.ByReferenceType).ElementType, typeAttributes, ref typeIndex, options) .MakePointerType(); } else if (type is Mono.Cecil.PointerType) { typeIndex++; return ConvertType((type as Mono.Cecil.PointerType).ElementType, typeAttributes, ref typeIndex, options) .MakePointerType(); } else if (type is Mono.Cecil.ArrayType) { typeIndex++; return ConvertType((type as Mono.Cecil.ArrayType).ElementType, typeAttributes, ref typeIndex, options) .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, options), HasNullableSpecifier = true }; } AstType baseType = ConvertType(gType.ElementType, typeAttributes, ref typeIndex, options & ~ConvertTypeOptions.IncludeTypeParameterDefinitions); List<AstType> typeArguments = new List<AstType>(); foreach (var typeArgument in gType.GenericArguments) { typeIndex++; typeArguments.Add(ConvertType(typeArgument, typeAttributes, ref typeIndex, options)); } 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, options & ~ConvertTypeOptions.IncludeTypeParameterDefinitions); string namepart = ICSharpCode.NRefactory.TypeSystem.ReflectionHelper.SplitTypeParameterCountFromReflectionName(type.Name); MemberType memberType = new MemberType { Target = typeRef, MemberName = namepart }; memberType.AddAnnotation(type); if ((options & ConvertTypeOptions.IncludeTypeParameterDefinitions) == ConvertTypeOptions.IncludeTypeParameterDefinitions) { AddTypeParameterDefininitionsTo(type, memberType); } return memberType; } 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); AstType astType; if ((options & ConvertTypeOptions.IncludeNamespace) == ConvertTypeOptions.IncludeNamespace && ns.Length > 0) { 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] }; } astType = new MemberType { Target = nsType, MemberName = name }; } else { astType = new SimpleType(name); } astType.AddAnnotation(type); if ((options & ConvertTypeOptions.IncludeTypeParameterDefinitions) == ConvertTypeOptions.IncludeTypeParameterDefinitions) { AddTypeParameterDefininitionsTo(type, astType); } return astType; } } }