public static AstType ConvertToTypeReference(this MonoDevelop.Projects.Dom.IReturnType returnType)
{
string primitiveType;
if (TypeTable.TryGetValue(returnType.DecoratedFullName, out primitiveType))
{
return(new PrimitiveType(primitiveType));
}
AstType result = null;
if (!string.IsNullOrEmpty(returnType.Namespace))
{
result = new SimpleType(returnType.Namespace);
}
foreach (var part in returnType.Parts)
{
if (result == null)
{
var st = new SimpleType(part.Name);
foreach (var type in part.GenericArguments.Select(ga => ConvertToTypeReference(ga)))
{
st.AddChild(type, SimpleType.Roles.TypeArgument);
}
result = st;
}
else
{
var mt = new ICSharpCode.NRefactory.CSharp.MemberType()
{
Target = result,
MemberName = part.Name
};
foreach (var type in part.GenericArguments.Select(ga => ConvertToTypeReference(ga)))
{
mt.AddChild(type, SimpleType.Roles.TypeArgument);
}
result = mt;
}
}
/*
* List<TypeReference> genericTypes = new List<TypeReference> ();
* foreach (MonoDevelop.Projects.Dom.IReturnType genericType in returnType.GenericArguments) {
* genericTypes.Add (ConvertToTypeReference (genericType));
* }
* TypeReference result = new AstType (returnType.FullName, genericTypes);
* result.IsKeyword = true;
* result.PointerNestingLevel = returnType.PointerNestingLevel;
* if (returnType.ArrayDimensions > 0) {
* int[] rankSpecfier = new int[returnType.ArrayDimensions];
* for (int i = 0; i < returnType.ArrayDimensions; i++) {
* rankSpecfier[i] = returnType.GetDimension (i);
* }
* result.RankSpecifier = rankSpecfier;
* }*/
return(result);
}
protected internal TypeExpression(NRefactory.MemberType memberType, IScope scope, INRefcatoryExpressionVisitor visitor)
: this(memberType, TypeDescription.Memeber, scope, visitor)
{
InternalType = memberType.GetActualType();
}
public static AstType ConvertToTypeReference (this MonoDevelop.Projects.Dom.IReturnType returnType)
{
string primitiveType;
if (TypeTable.TryGetValue (returnType.DecoratedFullName, out primitiveType))
return new PrimitiveType (primitiveType);
AstType result = null;
if (!string.IsNullOrEmpty (returnType.Namespace))
result = new SimpleType (returnType.Namespace);
foreach (var part in returnType.Parts) {
if (result == null) {
var st = new SimpleType (part.Name);
foreach (var type in part.GenericArguments.Select (ga => ConvertToTypeReference (ga)))
st.AddChild (type, SimpleType.Roles.TypeArgument);
result = st;
} else {
var mt = new ICSharpCode.NRefactory.CSharp.MemberType () {
Target = result,
MemberName = part.Name
};
foreach (var type in part.GenericArguments.Select (ga => ConvertToTypeReference (ga)))
mt.AddChild (type, SimpleType.Roles.TypeArgument);
result = mt;
}
}
/*
List<TypeReference> genericTypes = new List<TypeReference> ();
foreach (MonoDevelop.Projects.Dom.IReturnType genericType in returnType.GenericArguments) {
genericTypes.Add (ConvertToTypeReference (genericType));
}
TypeReference result = new AstType (returnType.FullName, genericTypes);
result.IsKeyword = true;
result.PointerNestingLevel = returnType.PointerNestingLevel;
if (returnType.ArrayDimensions > 0) {
int[] rankSpecfier = new int[returnType.ArrayDimensions];
for (int i = 0; i < returnType.ArrayDimensions; i++) {
rankSpecfier[i] = returnType.GetDimension (i);
}
result.RankSpecifier = rankSpecfier;
}*/
return result;
}
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);
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
MemberType o = other as MemberType;
return(o != null && this.IsDoubleColon == o.IsDoubleColon && MatchString(this.MemberName, o.MemberName) && this.Target.DoMatch(o.Target, match));
}
void IAstVisitor.VisitMemberType(MemberType memberType)
{
Visit(EnterMemberType, LeaveMemberType, memberType);
}
public static TypeExpression TypeExpression(NRefactory.MemberType memberType, IScope scope, INRefcatoryExpressionVisitor visitor)
{
return(new TypeExpression(memberType, scope, visitor));
}
public override object VisitMemberType(ICSharpCode.NRefactory.CSharp.MemberType memberType, object data)
{
possibleTypeReferences.Add(memberType);
return(null);
}
public virtual S VisitMemberType(MemberType memberType, T data)
{
return(VisitChildren(memberType, data));
}
public virtual S VisitMemberType(MemberType memberType, T data)
{
throw new NotImplementedException();
}
public override AstExpression VisitMemberType(NRefactory.MemberType memberType, IScope scope)
{
return(AstExpression.TypeExpression(memberType, scope, this));
}
