public CastExpression CastTo(AstType type)
{
return(new CastExpression {
Type = type, Expression = this
});
}
public CastExpression(AstType castToType, Expression expression)
{
AddChild(castToType, Roles.Type);
AddChild(expression, Roles.Expression);
}
public UsingAliasDeclaration(string alias, AstType import)
{
AddChild(Identifier.Create (alias), AliasRole);
AddChild(import, ImportRole);
}
private TypeExpression(NRefactory.AstType astType, TypeDescription typeDescription, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor) {
_astType = astType;
_typeDescription = typeDescription;
}
public TypeReferenceExpression(AstType type)
{
AddChild(type, Roles.Type);
}
public UsingDeclaration(AstType import)
{
AddChild(import, ImportRole);
}
public override AsExpression CastAs(AstType type)
{
return(new AsExpression {
Type = type, Expression = new ParenthesizedExpression(this)
});
}
public CastExpression CastTo(Type type)
{
return(new CastExpression {
Type = AstType.Create(type), Expression = this
});
}
public AsExpression CastAs(Type type)
{
return(new AsExpression {
Type = AstType.Create(type), Expression = this
});
}
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 UsingDeclaration(string nameSpace)
{
AddChild(AstType.Create(nameSpace), ImportRole);
}
ITypeReference ConvertType(AstType type, bool isInUsingDeclaration = false)
{
return(ConvertType(type, currentTypeDefinition, currentMethod, usingScope, isInUsingDeclaration));
}
DefaultExplicitInterfaceImplementation ConvertInterfaceImplementation(AstType interfaceType, string memberName)
{
return(new DefaultExplicitInterfaceImplementation(ConvertType(interfaceType), memberName));
}
public VariableDeclarationStatement(AstType type, string name, Expression initializer = null)
{
this.Type = type;
this.Variables.Add(new VariableInitializer(name, initializer));
}
public AsExpression CastAs(AstType type)
{
return(new AsExpression {
Type = type, Expression = this
});
}
public IsExpression IsType(Type type)
{
return(new IsExpression {
Type = AstType.Create(type), Expression = this
});
}
public IsExpression IsType(AstType type)
{
return(new IsExpression {
Type = type, Expression = this
});
}
public ParameterDeclaration(AstType type, string name)
{
this.Type = type;
this.Name = name;
}
public AsExpression(Expression expression, AstType type)
{
AddChild(expression, Roles.Expression);
AddChild(type, Roles.Type);
}
public MemberType(AstType target, string memberName)
{
this.Target = target;
this.MemberName = memberName;
}
public override IsExpression IsType(AstType type)
{
return(new IsExpression {
Type = type, Expression = new ParenthesizedExpression(this)
});
}
public MemberType(AstType target, string memberName, params AstType[] typeArguments) : this(target, memberName, (IEnumerable <AstType>)typeArguments)
{
}
private TypeExpression(NRefactory.AstType astType, TypeDescription typeDescription, IScope scope, INRefcatoryExpressionVisitor visitor)
: base(scope, visitor)
{
_astType = astType;
_typeDescription = typeDescription;
}
public ObjectCreateExpression(AstType type, params Expression[] arguments) : this(type, (IEnumerable <Expression>)arguments)
{
}
