public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) { IReturnType type = ResolveType(unaryOperatorExpression.Expression); if (type == null) { return(null); } switch (unaryOperatorExpression.Op) { case UnaryOperatorType.AddressOf: return(CreateResolveResult(new PointerReturnType(type))); case UnaryOperatorType.Dereference: PointerReturnType prt = type.CastToDecoratingReturnType <PointerReturnType>(); if (prt != null) { return(CreateResolveResult(prt.BaseType)); } else { return(null); } default: return(CreateResolveResult(type)); } }
void WriteType(IReturnType rt) { if (rt == null) { writer.Write(NullRTReferenceCode); return; } if (rt.IsDefaultReturnType) { string name = rt.FullyQualifiedName; if (name == "System.Void") { writer.Write(VoidRTCode); } else { writer.Write(classIndices[new ClassNameTypeCountPair(rt)]); } } else if (rt.IsGenericReturnType) { GenericReturnType grt = rt.CastToGenericReturnType(); if (grt.TypeParameter.Method != null) { writer.Write(MethodGenericRTCode); } else { writer.Write(TypeGenericRTCode); } writer.Write(grt.TypeParameter.Index); } else if (rt.IsArrayReturnType) { writer.Write(ArrayRTCode); writer.Write(rt.CastToArrayReturnType().ArrayDimensions); WriteType(rt.CastToArrayReturnType().ArrayElementType); } else if (rt.IsConstructedReturnType) { ConstructedReturnType crt = rt.CastToConstructedReturnType(); writer.Write(ConstructedRTCode); WriteType(crt.UnboundType); writer.Write((byte)crt.TypeArguments.Count); foreach (IReturnType typeArgument in crt.TypeArguments) { WriteType(typeArgument); } } else if (rt.IsDecoratingReturnType <PointerReturnType>()) { writer.Write(PointerRTCode); WriteType(rt.CastToDecoratingReturnType <PointerReturnType>().BaseType); } else { writer.Write(NullRTReferenceCode); LoggingService.Warn("Unknown return type: " + rt.ToString()); } }
public virtual T CastToDecoratingReturnType <T>() where T : DecoratingReturnType { IReturnType baseType = BaseType; using (var l = busyManager.Enter(this)) { return((l.Success && baseType != null) ? baseType.CastToDecoratingReturnType <T>() : null); } }
public override bool Equals(IReturnType rt) { if (rt == null) { return(false); } PointerReturnType prt = rt.CastToDecoratingReturnType <PointerReturnType>(); if (prt == null) { return(false); } return(baseType.Equals(prt.baseType)); }
public override bool Equals(IReturnType other) { if (other == null) { return(false); } AnonymousMethodReturnType o = other.CastToDecoratingReturnType <AnonymousMethodReturnType>(); if (o == null) { return(false); } return(this.FullyQualifiedName == o.FullyQualifiedName); }
public override T CastToDecoratingReturnType <T>() { if (typeof(T) == typeof(ReferenceReturnType)) { return((T)(object)this); } else if (baseType != null) { return(baseType.CastToDecoratingReturnType <T>()); } else { return(null); } }
public virtual T CastToDecoratingReturnType <T>() where T : DecoratingReturnType { IReturnType baseType = BaseType; T temp; if (baseType != null && TryEnter()) { temp = baseType.CastToDecoratingReturnType <T>(); } else { temp = null; } Leave(); return(temp); }
public override object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) { IReturnType type = ResolveType(unaryOperatorExpression.Expression); if (type == null) { return(null); } switch (unaryOperatorExpression.Op) { case UnaryOperatorType.AddressOf: return(CreateResolveResult(new PointerReturnType(type))); case UnaryOperatorType.Dereference: PointerReturnType prt = type.CastToDecoratingReturnType <PointerReturnType>(); if (prt != null) { return(CreateResolveResult(prt.BaseType)); } else { return(null); } case UnaryOperatorType.Await: var crt = type.CastToConstructedReturnType(); if (crt != null && crt.Name == "Task" && crt.TypeArguments.Count == 1) { return(CreateResolveResult(crt.TypeArguments[0])); } else { return(null); } default: return(CreateResolveResult(type)); } }
void AddExternalType(IReturnType rt, List <ClassNameTypeCountPair> externalTypes, int classCount) { if (rt.IsDefaultReturnType) { ClassNameTypeCountPair pair = new ClassNameTypeCountPair(rt); if (!classIndices.ContainsKey(pair)) { classIndices.Add(pair, externalTypes.Count + classCount); externalTypes.Add(pair); } } else if (rt.IsGenericReturnType) { // ignore } else if (rt.IsArrayReturnType) { AddExternalType(rt.CastToArrayReturnType().ArrayElementType, externalTypes, classCount); } else if (rt.IsConstructedReturnType) { AddExternalType(rt.CastToConstructedReturnType().UnboundType, externalTypes, classCount); foreach (IReturnType typeArgument in rt.CastToConstructedReturnType().TypeArguments) { AddExternalType(typeArgument, externalTypes, classCount); } } else if (rt.IsDecoratingReturnType <PointerReturnType>()) { AddExternalType(rt.CastToDecoratingReturnType <PointerReturnType>().BaseType, externalTypes, classCount); } else { LoggingService.Warn("Unknown return type: " + rt.ToString()); } }
void WriteType(IReturnType rt) { if (rt == null) { writer.Write(NullRTReferenceCode); return; } if (rt.IsDefaultReturnType) { string name = rt.FullyQualifiedName; if (name == "System.Void") { writer.Write(VoidRTCode); } else { writer.Write(classIndices[new ClassNameTypeCountPair(rt)]); } } else if (rt.IsGenericReturnType) { GenericReturnType grt = rt.CastToGenericReturnType(); if (grt.TypeParameter.Method != null) { writer.Write(MethodGenericRTCode); } else { writer.Write(TypeGenericRTCode); } writer.Write(grt.TypeParameter.Index); } else if (rt.IsArrayReturnType) { writer.Write(ArrayRTCode); writer.Write(rt.CastToArrayReturnType().ArrayDimensions); WriteType(rt.CastToArrayReturnType().ArrayElementType); } else if (rt.IsConstructedReturnType) { ConstructedReturnType crt = rt.CastToConstructedReturnType(); writer.Write(ConstructedRTCode); WriteType(crt.UnboundType); writer.Write((byte)crt.TypeArguments.Count); foreach (IReturnType typeArgument in crt.TypeArguments) { WriteType(typeArgument); } } else if (rt.IsDecoratingReturnType<PointerReturnType>()) { writer.Write(PointerRTCode); WriteType(rt.CastToDecoratingReturnType<PointerReturnType>().BaseType); } else { writer.Write(NullRTReferenceCode); LoggingService.Warn("Unknown return type: " + rt.ToString()); } }
void AddExternalType(IReturnType rt, List<ClassNameTypeCountPair> externalTypes, int classCount) { if (rt.IsDefaultReturnType) { ClassNameTypeCountPair pair = new ClassNameTypeCountPair(rt); if (!classIndices.ContainsKey(pair)) { classIndices.Add(pair, externalTypes.Count + classCount); externalTypes.Add(pair); } } else if (rt.IsGenericReturnType) { // ignore } else if (rt.IsArrayReturnType) { AddExternalType(rt.CastToArrayReturnType().ArrayElementType, externalTypes, classCount); } else if (rt.IsConstructedReturnType) { AddExternalType(rt.CastToConstructedReturnType().UnboundType, externalTypes, classCount); foreach (IReturnType typeArgument in rt.CastToConstructedReturnType().TypeArguments) { AddExternalType(typeArgument, externalTypes, classCount); } } else if (rt.IsDecoratingReturnType<PointerReturnType>()) { AddExternalType(rt.CastToDecoratingReturnType<PointerReturnType>().BaseType, externalTypes, classCount); } else { LoggingService.Warn("Unknown return type: " + rt.ToString()); } }
public static TypeReference ConvertType(IReturnType returnType, ClassFinder context) { if (returnType == null) { return(TypeReference.Null); } if (returnType is NullReturnType) { return(TypeReference.Null); } ArrayReturnType arrayReturnType = returnType.CastToArrayReturnType(); if (arrayReturnType != null) { TypeReference typeRef = ConvertType(arrayReturnType.ArrayElementType, context); int[] rank = typeRef.RankSpecifier ?? new int[0]; Array.Resize(ref rank, rank.Length + 1); rank[rank.Length - 1] = arrayReturnType.ArrayDimensions - 1; typeRef.RankSpecifier = rank; return(typeRef); } PointerReturnType pointerReturnType = returnType.CastToDecoratingReturnType <PointerReturnType>(); if (pointerReturnType != null) { TypeReference typeRef = ConvertType(pointerReturnType.BaseType, context); typeRef.PointerNestingLevel++; return(typeRef); } IList <IReturnType> typeArguments = EmptyList <IReturnType> .Instance; if (returnType.IsConstructedReturnType) { typeArguments = returnType.CastToConstructedReturnType().TypeArguments; } IClass c = returnType.GetUnderlyingClass(); if (c != null) { return(CreateTypeReference(c, typeArguments, context)); } else { TypeReference typeRef; if (IsPrimitiveType(returnType)) { typeRef = new TypeReference(returnType.FullyQualifiedName, true); } else if (context != null && CanUseShortTypeName(returnType, context)) { typeRef = new TypeReference(returnType.Name); } else { string fullName = returnType.FullyQualifiedName; if (string.IsNullOrEmpty(fullName)) { fullName = returnType.Name; } typeRef = new TypeReference(fullName); } foreach (IReturnType typeArgument in typeArguments) { typeRef.GenericTypes.Add(ConvertType(typeArgument, context)); } return(typeRef); } }
/// <summary> /// Tests if an implicit conversion exists from "from" to "to". /// Conversions from concrete types to generic types are only allowed when the generic type belongs to the /// method "allowGenericTargetsOnThisMethod". /// </summary> static bool ConversionExistsInternal(IReturnType from, IReturnType to, IMethod allowGenericTargetsOnThisMethod) { // ECMA-334, § 13.1 Implicit conversions // Identity conversion: if (from == to) { return(true); } if (from == null || to == null) { return(false); } if (from.Equals(to)) { return(true); } bool fromIsDefault = from.IsDefaultReturnType; bool toIsDefault = to.IsDefaultReturnType; if (fromIsDefault && toIsDefault) { // Implicit numeric conversions: int f = GetPrimitiveType(from); int t = GetPrimitiveType(to); if (f == SByte && (t == Short || t == Int || t == Long || t == Float || t == Double || t == Decimal)) { return(true); } if (f == Byte && (t == Short || t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal)) { return(true); } if (f == Short && (t == Int || t == Long || t == Float || t == Double || t == Decimal)) { return(true); } if (f == UShort && (t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal)) { return(true); } if (f == Int && (t == Long || t == Float || t == Double || t == Decimal)) { return(true); } if (f == UInt && (t == Long || t == ULong || t == Float || t == Double || t == Decimal)) { return(true); } if ((f == Long || f == ULong) && (t == Float || t == Double || t == Decimal)) { return(true); } if (f == Char && (t == UShort || t == Int || t == UInt || t == Long || t == ULong || t == Float || t == Double || t == Decimal)) { return(true); } if (f == Float && t == Double) { return(true); } } // Implicit reference conversions: if (toIsDefault && to.FullyQualifiedName == "System.Object") { return(true); // from any type to object } if (from == NullReturnType.Instance) { IClass toClass = to.GetUnderlyingClass(); if (toClass != null) { switch (toClass.ClassType) { case ClassType.Class: case ClassType.Delegate: case ClassType.Interface: return(true); case ClassType.Struct: return(toClass.FullyQualifiedName == "System.Nullable"); } } return(false); } if ((toIsDefault || to.IsConstructedReturnType || to.IsGenericReturnType) && (fromIsDefault || from.IsArrayReturnType || from.IsConstructedReturnType)) { foreach (IReturnType baseTypeOfFrom in GetTypeInheritanceTree(from)) { if (IsConstructedConversionToGenericReturnType(baseTypeOfFrom, to, allowGenericTargetsOnThisMethod)) { return(true); } } } if (from.IsArrayReturnType && to.IsArrayReturnType) { ArrayReturnType fromArt = from.CastToArrayReturnType(); ArrayReturnType toArt = to.CastToArrayReturnType(); // from array to other array type if (fromArt.ArrayDimensions == toArt.ArrayDimensions) { return(ConversionExistsInternal(fromArt.ArrayElementType, toArt.ArrayElementType, allowGenericTargetsOnThisMethod)); } } if (from.IsDecoratingReturnType <AnonymousMethodReturnType>() && (toIsDefault || to.IsConstructedReturnType)) { AnonymousMethodReturnType amrt = from.CastToDecoratingReturnType <AnonymousMethodReturnType>(); IMethod method = CSharp.TypeInference.GetDelegateOrExpressionTreeSignature(to, amrt.CanBeConvertedToExpressionTree); if (method != null) { if (amrt.HasParameterList) { if (amrt.MethodParameters.Count != method.Parameters.Count) { return(false); } for (int i = 0; i < amrt.MethodParameters.Count; i++) { if (amrt.MethodParameters[i].ReturnType != null) { if (!object.Equals(amrt.MethodParameters[i].ReturnType, method.Parameters[i].ReturnType)) { return(false); } } } } IReturnType rt = amrt.ResolveReturnType(method.Parameters.Select(p => p.ReturnType).ToArray()); return(ConversionExistsInternal(rt, method.ReturnType, allowGenericTargetsOnThisMethod)); } } return(false); }