public override void VisitComposedType(ComposedType composedType)
{
var spec = composedType.ArraySpecifiers.FirstOrDefault();
if (spec != null)
{
ForceSpacesBefore(spec.LBracketToken, policy.SpaceBeforeArrayDeclarationBrackets);
}
if (composedType.HasNullableSpecifier)
{
ForceSpacesBefore(composedType.NullableSpecifierToken, false);
}
if (composedType.PointerRank > 0)
{
foreach (var token in composedType.PointerTokens)
{
ForceSpacesBefore(token, false);
}
}
base.VisitComposedType(composedType);
}
void IAstVisitor.VisitComposedType(ComposedType composedType)
{
Visit(EnterComposedType, LeaveComposedType, composedType);
}
protected internal override bool DoMatch(AstNode other, PatternMatching.Match match)
{
ComposedType o = other as ComposedType;
return(o != null && this.HasNullableSpecifier == o.HasNullableSpecifier && this.PointerRank == o.PointerRank && this.ArraySpecifiers.DoMatch(o.ArraySpecifiers, match));
}
public virtual S VisitComposedType(ComposedType composedType, T data)
{
return(VisitChildren(composedType, data));
}
public TypeExpression(NRefactory.ComposedType composedType, IScope scope, INRefcatoryExpressionVisitor visitor)
: this(composedType, TypeDescription.Composed, scope, visitor)
{
InternalType = composedType.GetActualType();
}
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);
}
public static TypeExpression TypeExpression(NRefactory.ComposedType composedType, IScope scope, INRefcatoryExpressionVisitor visitor)
{
return(new TypeExpression(composedType, scope, visitor));
}
public virtual S VisitComposedType(ComposedType composedType, T data)
{
throw new NotImplementedException();
}
public override AstExpression VisitComposedType(NRefactory.ComposedType composedType, IScope scope)
{
return(AstExpression.TypeExpression(composedType, scope, this));
}