public override ITypeReference ToTypeReference(SimpleNameLookupMode lookupMode = SimpleNameLookupMode.Type)
{
TypeOrNamespaceReference t;
if (this.IsDoubleColon)
{
SimpleType st = this.Target as SimpleType;
if (st != null)
{
t = new AliasNamespaceReference(st.Identifier);
}
else
{
t = null;
}
}
else
{
t = this.Target.ToTypeReference(lookupMode) as TypeOrNamespaceReference;
}
if (t == null)
{
return(SpecialType.UnknownType);
}
var typeArguments = new List <ITypeReference>();
foreach (var ta in this.TypeArguments)
{
typeArguments.Add(ta.ToTypeReference(lookupMode));
}
return(new MemberTypeOrNamespaceReference(t, this.MemberName, typeArguments));
}
public AstType ConvertTypeReference(ITypeReference typeRef)
{
ArrayTypeReference array = typeRef as ArrayTypeReference;
if (array != null)
{
return(ConvertTypeReference(array.ElementType).MakeArrayType(array.Dimensions));
}
PointerTypeReference pointer = typeRef as PointerTypeReference;
if (pointer != null)
{
return(ConvertTypeReference(pointer.ElementType).MakePointerType());
}
ByReferenceType brt = typeRef as ByReferenceType;
if (brt != null)
{
return(ConvertTypeReference(brt.ElementType));
}
IType type = typeRef.Resolve(context);
if (type.Kind != TypeKind.Unknown)
{
return(ConvertType(type));
}
// Unknown type, let's try if we can find an appropriate type
// (anything is better than displaying a question mark)
KnownTypeReference knownType = typeRef as KnownTypeReference;
if (knownType != null)
{
string keyword = ReflectionHelper.GetCSharpNameByTypeCode(knownType.TypeCode);
if (keyword != null)
{
return(new PrimitiveType(keyword));
}
}
SimpleTypeOrNamespaceReference str = typeRef as SimpleTypeOrNamespaceReference;
if (str != null)
{
return(new SimpleType(str.Identifier, str.TypeArguments.Select(ConvertTypeReference)));
}
MemberTypeOrNamespaceReference mtr = typeRef as MemberTypeOrNamespaceReference;
if (mtr != null)
{
return(new MemberType(ConvertTypeReference(mtr.Target), mtr.Identifier, mtr.TypeArguments.Select(ConvertTypeReference))
{
IsDoubleColon = mtr.Target is AliasNamespaceReference
});
}
AliasNamespaceReference alias = typeRef as AliasNamespaceReference;
if (alias != null)
{
return(new SimpleType(alias.Identifier));
}
// Unknown type reference that couldn't be resolved
return(new SimpleType("?"));
}
internal static ITypeReference ConvertType(AstType type, ITypeDefinition parentTypeDefinition, IMethod parentMethodDefinition, UsingScope parentUsingScope, bool isInUsingDeclaration)
{
SimpleType s = type as SimpleType;
if (s != null)
{
List <ITypeReference> typeArguments = new List <ITypeReference>();
foreach (var ta in s.TypeArguments)
{
typeArguments.Add(ConvertType(ta, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration));
}
if (typeArguments.Count == 0 && parentMethodDefinition != null)
{
// SimpleTypeOrNamespaceReference doesn't support method type parameters,
// so we directly handle them here.
foreach (ITypeParameter tp in parentMethodDefinition.TypeParameters)
{
if (tp.Name == s.Identifier)
{
return(tp);
}
}
}
return(new SimpleTypeOrNamespaceReference(s.Identifier, typeArguments, parentTypeDefinition, parentUsingScope, isInUsingDeclaration));
}
PrimitiveType p = type as PrimitiveType;
if (p != null)
{
switch (p.Keyword)
{
case "string":
return(KnownTypeReference.String);
case "int":
return(KnownTypeReference.Int32);
case "uint":
return(KnownTypeReference.UInt32);
case "object":
return(KnownTypeReference.Object);
case "bool":
return(KnownTypeReference.Boolean);
case "sbyte":
return(KnownTypeReference.SByte);
case "byte":
return(KnownTypeReference.Byte);
case "short":
return(KnownTypeReference.Int16);
case "ushort":
return(KnownTypeReference.UInt16);
case "long":
return(KnownTypeReference.Int64);
case "ulong":
return(KnownTypeReference.UInt64);
case "float":
return(KnownTypeReference.Single);
case "double":
return(KnownTypeReference.Double);
case "decimal":
return(ReflectionHelper.ToTypeReference(TypeCode.Decimal));
case "char":
return(KnownTypeReference.Char);
case "void":
return(KnownTypeReference.Void);
default:
return(SharedTypes.UnknownType);
}
}
MemberType m = type as MemberType;
if (m != null)
{
ITypeOrNamespaceReference t;
if (m.IsDoubleColon)
{
SimpleType st = m.Target as SimpleType;
if (st != null)
{
t = new AliasNamespaceReference(st.Identifier, parentUsingScope);
}
else
{
t = null;
}
}
else
{
t = ConvertType(m.Target, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration) as ITypeOrNamespaceReference;
}
if (t == null)
{
return(SharedTypes.UnknownType);
}
List <ITypeReference> typeArguments = new List <ITypeReference>();
foreach (var ta in m.TypeArguments)
{
typeArguments.Add(ConvertType(ta, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration));
}
return(new MemberTypeOrNamespaceReference(t, m.MemberName, typeArguments, parentTypeDefinition, parentUsingScope));
}
ComposedType c = type as ComposedType;
if (c != null)
{
ITypeReference t = ConvertType(c.BaseType, parentTypeDefinition, parentMethodDefinition, parentUsingScope, isInUsingDeclaration);
if (c.HasNullableSpecifier)
{
t = NullableType.Create(t);
}
for (int i = 0; i < c.PointerRank; i++)
{
t = PointerTypeReference.Create(t);
}
foreach (var a in c.ArraySpecifiers.Reverse())
{
t = ArrayTypeReference.Create(t, a.Dimensions);
}
return(t);
}
Debug.WriteLine("Unknown node used as type: " + type);
return(SharedTypes.UnknownType);
}
