/// <summary>
/// Clone the properties of valueArg into node.
/// </summary>
private static void CopyEnumValueOf(AstExpression node, XTypeReference type, AstExpression valueArg)
{
// Clear node
node.Arguments.Clear();
node.InferredType = type;
node.ExpectedType = type;
switch (valueArg.Code)
{
case AstCode.Ldloca:
node.Code = AstCode.Ldloc;
break;
case AstCode.Ldflda:
node.Code = AstCode.Ldfld;
break;
case AstCode.Ldsflda:
node.Code = AstCode.Ldsfld;
break;
default:
node.Code = valueArg.Code;
break;
}
node.Operand = valueArg.Operand;
node.Arguments.AddRange(valueArg.Arguments);
ConvertLoadArguments(node, type);
}
/// <summary>
/// Generate an Add opcode.
/// </summary>
private static RCode OpcodeForType(XTypeReference type, RCode[] opcodes)
{
if (type.IsInt32() || type.IsUInt32() || type.IsInt16() || type.IsUInt16() || type.IsChar() || type.IsByte() || type.IsSByte() || type.IsBoolean())
{
return(opcodes[0]);
}
if (type.IsInt64() || type.IsUInt64())
{
return(opcodes[1]);
}
if (type.IsFloat())
{
return(opcodes[2]);
}
if (type.IsDouble())
{
return(opcodes[3]);
}
XTypeDefinition typeDef;
if (type.TryResolve(out typeDef))
{
if (typeDef.IsEnum)
{
return(OpcodeForType(typeDef.GetEnumUnderlyingType(), opcodes));
}
}
throw new ArgumentException("Unsupported type " + type);
}
private static void BoxIfGeneric(XTypeReference type, AstExpression node)
{
// TODO: CLR allows return-by-reference, though C# does not. Do we need to handle this here?
if (type.IsGenericParameter)
{
var resultType = node.GetResultType();
if (resultType.IsPrimitive)
{
var clone = new AstExpression(node);
node.SetCode(AstCode.BoxToGeneric)
.SetArguments(clone)
.Operand = type;
}
}
else if (type.IsGenericParameterArray())
{
var resultType = node.GetResultType().ElementType;
if (resultType.IsPrimitive)
{
var clone = new AstExpression(node);
node.SetCode(AstCode.BoxToGeneric).SetArguments(clone).Operand = type;
}
}
}
/// <summary>
/// Variable ctor
/// </summary>
public AstILVariable(string name, XTypeReference type, VariableDefinition originalVariable, string originalVariableName)
{
Name = name;
Type = type;
this.originalVariable = originalVariable;
this.originalVariableName = originalVariableName;
}
/// <summary>
/// Generate converter for the value of an Const instruction.
/// </summary>
internal static Func <object, object> ConstValueConverter(this XTypeReference elementType, bool keepUnsigned)
{
if (elementType.IsBoolean())
{
return(x => Convert.ToBoolean(x) ? 1 : 0);
}
if (elementType.IsByte())
{
if (keepUnsigned)
{
return(x => (int)Convert.ToByte(x));
}
return(x => (int)((sbyte)unchecked (Convert.ToByte(x))));
}
if (elementType.IsSByte())
{
return(x => (int)(Convert.ToSByte(x)));
}
if (elementType.IsChar())
{
return(x => (int)(Convert.ToChar(x)));
}
if (elementType.IsUInt16())
{
return(x => (int)(Convert.ToUInt16(x)));
}
if (elementType.IsInt16())
{
return(x => (int)(Convert.ToInt16(x)));
}
if (elementType.IsInt32())
{
return(x => XConvert.ToInt(x));
}
if (elementType.IsUInt32())
{
return(x => XConvert.ToInt(x)); // unchecked((int)Convert.ToUInt32(Convert.ToInt64(x) & 0xFFFFFFFF));
}
if (elementType.IsFloat())
{
return(x => Convert.ToSingle(x));
}
if (elementType.IsInt64())
{
return(x => XConvert.ToLong(x));
}
if (elementType.IsUInt64())
{
return(x => XConvert.ToLong(x)); // unchecked((long)Convert.ToInt64(x));
}
if (elementType.IsDouble())
{
return(x => Convert.ToDouble(x));
}
if (elementType.IsDexObject() && !elementType.IsVoid())
{
return(x => x);
}
throw new NotSupportedException("Unknown type for constValueConverter " + elementType);
}
/// <summary>
/// Convert a nullable ctor into a convert function.
/// </summary>
private static void ConvertOtherCtor(AstExpression node, XTypeReference type, AstExpression target, AstExpression value)
{
// Clear node
node.Arguments.Clear();
node.InferredType = type;
node.ExpectedType = type;
switch (target.Code)
{
case AstCode.Ldloca:
node.Code = AstCode.Stloc;
node.Operand = target.Operand;
node.Arguments.Add(value);
break;
case AstCode.Ldflda:
node.Code = AstCode.Stfld;
node.Operand = target.Operand;
node.Arguments.Add(value);
break;
case AstCode.Ldsflda:
node.Code = AstCode.Stsfld;
node.Operand = target.Operand;
node.Arguments.Add(value);
break;
}
ConvertLoadArguments(node, type);
}
/// <summary>
/// Convert ret or store field node.
///
/// converts to IEnumerable, ICollection or IList if required.
/// </summary>
private static void ConvertRetOrStfldOrStsfld(AssemblyCompiler compiler, XTypeReference targetType, AstExpression node, XTypeSystem typeSystem)
{
var argument = node.Arguments.LastOrDefault();
if (argument == null)
{
return;
}
if (argument.InferredType == null || !argument.InferredType.IsArray)
{
return;
}
var methodName = GetCollectionConvertMethodName(targetType);
if (methodName == null)
{
return;
}
// Call "ret asMethod(x)"
var arrayHelper = compiler.GetDot42InternalType(InternalConstants.CompilerHelperName).Resolve();
var asArray = arrayHelper.Methods.First(x => x.Name == "As" + methodName);
// AsX(x)
var asXExpr = new AstExpression(node.SourceLocation, AstCode.Call, asArray, argument).SetType(typeSystem.Object);
// replace argument.
node.Arguments[node.Arguments.Count - 1] = asXExpr;
}
private static string GetCollectionConvertMethodName(XTypeReference targetType)
{
if (targetType.IsSystemCollectionsIEnumerable())
{
return("Enumerable");
}
if (targetType.IsSystemCollectionsIEnumerableT())
{
return("EnumerableOfObject");
}
if (targetType.IsSystemCollectionsICollection())
{
return("Collection");
}
if (targetType.IsSystemCollectionsICollectionT())
{
return("CollectionOfObject");
}
if (targetType.IsSystemCollectionsIList())
{
return("List");
}
if (targetType.IsSystemCollectionsIListT())
{
return("ListOfObject");
}
return(null);
}
private static void UnboxIfGeneric(XTypeReference type, AstExpression node, XTypeSystem typeSystem)
{
if (type.IsGenericParameter || type.IsGenericParameterArray())
{
var resultType = node.GetResultType();
if (resultType.IsByReference && !type.IsByReference)
{
var elementType = resultType.ElementType;
var clone = new AstExpression(node);
node.SetCode(AstCode.SimpleCastclass).SetArguments(clone).Operand = elementType;
}
else
{
if (TreatAsStruct(type, resultType))
{
ConvertUnboxStruct(node, resultType, typeSystem);
}
else
{
var clone = new AstExpression(node);
node.SetCode(AstCode.UnboxFromGeneric).SetArguments(clone).Operand = type;
}
}
}
}
/// <summary>
/// Convert the given argument if it does not match the target type.
/// </summary>
private static void ConvertForRetIfNeeded(AstExpression arg, XTypeReference targetType)
{
var argType = arg.GetResultType();
if (!targetType.IsSame(argType))
{
if (targetType.IsChar())
{
if (argType.IsUInt16() || argType.IsByte() || argType.IsInt16())
{
Convert(arg, AstCode.Conv_U2, targetType);
}
}
else if (targetType.IsUInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Int_to_ushort, targetType);
}
}
else if (targetType.IsInt16())
{
if (argType.IsChar() || argType.IsByte())
{
Convert(arg, AstCode.Conv_I2, targetType);
}
}
}
}
/// <summary>
/// Gets the type of stelem code to use for the given element type.
/// </summary>
public static AstCode GetStElemCode(this XTypeReference elementType)
{
if (elementType.IsByte() || elementType.IsSByte() || elementType.IsBoolean())
{
return(AstCode.Stelem_I1);
}
if (elementType.IsChar() || elementType.IsInt16() || elementType.IsUInt16())
{
return(AstCode.Stelem_I2);
}
if (elementType.IsInt32() || elementType.IsUInt32())
{
return(AstCode.Stelem_I4);
}
if (elementType.IsInt64() || elementType.IsUInt64())
{
return(AstCode.Stelem_I8);
}
if (elementType.IsFloat())
{
return(AstCode.Stelem_R4);
}
if (elementType.IsDouble())
{
return(AstCode.Stelem_R8);
}
return(AstCode.Stelem_Ref);
}
/// <summary>
/// Gets a box method for the given primitive type.
/// </summary>
internal static MethodReference GetBoxValueOfMethod(XTypeReference type)
{
var info = Get(type);
var cref = info.boxedClass;
return(new MethodReference(cref, "valueOf", new Prototype(cref, new Parameter(info.primitiveType, "value"))));
}
/// <summary>
/// Convert a nullable .GetValueOrDefault()
/// </summary>
private static void ConvertGetValueOrDefault(AstExpression node, XTypeReference type, XModule module)
{
var defExpr = node.Arguments.Count == 1
? new AstExpression(node.SourceLocation, AstCode.DefaultValue, type).SetType(type)
: node.Arguments[1];
defExpr.ExpectedType = type;
if (type.IsPrimitive)
{
// replace with obj != null ? unbox(obj) : defExpr
AstExpression compareExpr, valueExpr;
var loadExpr = node.Arguments[0];
ConvertLoad(loadExpr);
loadExpr.InferredType = module.TypeSystem.Object;
loadExpr.ExpectedType = module.TypeSystem.Object;
if (loadExpr.Code != AstCode.Ldloc)
{
// TODO: how can we get the backend to remove/combine these variables again?
var tmpVar = new AstGeneratedVariable("tmp$", null)
{
Type = module.TypeSystem.Object
};
compareExpr = new AstExpression(node.SourceLocation, AstCode.Stloc, tmpVar, loadExpr).SetType(module.TypeSystem.Object);
valueExpr = new AstExpression(node.SourceLocation, AstCode.Ldloc, tmpVar).SetType(module.TypeSystem.Object);
}
else
{
compareExpr = loadExpr;
valueExpr = loadExpr;
}
valueExpr = new AstExpression(node.SourceLocation, AstCode.Unbox, type, valueExpr).SetType(type);
var newNode = new AstExpression(node.SourceLocation, AstCode.Conditional, type,
compareExpr, valueExpr, defExpr)
.SetType(type);
node.CopyFrom(newNode);
}
else
{
// replace with obj ?? defExpr
var loadExpr = node.Arguments[0];
ConvertLoad(loadExpr);
if (!type.IsSame(loadExpr.InferredType))
{
//loadExpr.ExpectedType = type;
// todo: how to get the cast inserted automatically?
loadExpr = new AstExpression(loadExpr.SourceLocation, AstCode.SimpleCastclass, type, loadExpr);
}
var nullCoalescing = new AstExpression(node.SourceLocation, AstCode.NullCoalescing, null, loadExpr, defExpr);
nullCoalescing.InferredType = type;
node.CopyFrom(nullCoalescing);
}
}
/// <summary>
/// Default ctor
/// </summary>
private XSyntheticFieldDefinition(XTypeDefinition declaringType, XSyntheticFieldFlags flags, string name, XTypeReference fieldType, object initialValue)
: base(declaringType)
{
this.flags = flags;
this.name = name;
this.fieldType = fieldType;
this.initialValue = initialValue;
}
/// <summary>
/// Default ctor
/// </summary>
private XSyntheticFieldDefinition(XTypeDefinition declaringType, XSyntheticFieldFlags flags, string name, XTypeReference fieldType, object initialValue)
: base(declaringType)
{
this.flags = flags;
this.name = name;
this.fieldType = fieldType;
this.initialValue = initialValue;
}
/// <summary>
/// Default ctor
/// </summary>
private XSyntheticMethodDefinition(XTypeDefinition declaringType, XSyntheticMethodFlags flags, string name, XTypeReference returnType, params XParameter[] parameters)
: base(declaringType)
{
this.flags = flags;
this.name = name;
this.returnType = returnType;
this.parameters = parameters.ToList();
astParameters = parameters.Select(x => new AstParameterVariable(x)).Cast <AstVariable>().ToList();
}
/// <summary>
/// Create a synthetic field and add it to the given declaring type.
/// </summary>
public static XSyntheticTypeDefinition Create(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType, string fullScopeId)
{
var type = new XSyntheticTypeDefinition(module, declaringType, flags, @namespace, name, baseType, fullScopeId);
if(declaringType != null)
declaringType.Add(type);
module.Register(type);
return type;
}
/// <summary>
/// Default ctor
/// </summary>
public JavaFieldReference(string name, XTypeReference fieldType, XTypeReference declaringType, string javaName, string javaDescriptor, string javaClassName)
: base(declaringType)
{
this.name = name;
this.fieldType = fieldType;
this.javaName = javaName;
this.javaDescriptor = javaDescriptor;
this.javaClassName = javaClassName;
}
/// <summary>
/// Gets a unbox method for the given primitive type.
/// </summary>
internal static MethodReference GetUnboxValueMethod(XTypeReference type, AssemblyCompiler compiler, DexTargetPackage targetPackage, out RCode convertAfterCode)
{
var info = Get(type);
convertAfterCode = info.convertAfterCode;
var boxingClass = compiler.GetDot42InternalType("Boxing").GetClassReference(targetPackage);
return(new MethodReference(boxingClass, info.unboxMethodName, new Prototype(info.primitiveType, new Parameter(FrameworkReferences.Object, "value"))));
}
/// <summary>
/// Default ctor
/// </summary>
public JavaFieldReference(string name, XTypeReference fieldType, XTypeReference declaringType, string javaName, string javaDescriptor, string javaClassName)
: base(declaringType)
{
this.name = name;
this.fieldType = fieldType;
this.javaName = javaName;
this.javaDescriptor = javaDescriptor;
this.javaClassName = javaClassName;
}
/// <summary>
/// Variable ctor
/// </summary>
public AstJavaVariable(XTypeReference type, LocalVariableReference varRef)
{
this.varRef = varRef;
index = varRef.Index;
isParameter = varRef.IsParameter;
isThis = varRef.IsThis;
Name = (isParameter ? "_P" : "_V") + varRef;
Type = type;
}
/// <summary>
/// Convert the given node to a box operation with given type and argument.
/// </summary>
private static void ConvertToBox(AstExpression node, XTypeReference boxType, AstExpression argument)
{
node.Code = AstCode.Box;
node.Operand = boxType;
node.InferredType = boxType;
node.ExpectedType = boxType;
node.Arguments.Clear();
node.Arguments.Add(argument);
}
/// <summary>
/// Returns the method name when converting an array to an IEnumerableT in compiler helper.
///
/// (not sure if this is the best place for this method...)
/// </summary>
public static string GetAsEnumerableTMethodName(XTypeReference sourceArrayElementType)
{
var convertMethodName = "AsObjectEnumerable";
if (sourceArrayElementType.IsPrimitive)
{
if (sourceArrayElementType.IsBoolean())
{
convertMethodName = "AsBoolEnumerable";
}
else if (sourceArrayElementType.IsByte())
{
convertMethodName = "AsByteEnumerable";
}
else if (sourceArrayElementType.IsSByte())
{
convertMethodName = "AsSByteEnumerable";
}
else if (sourceArrayElementType.IsChar())
{
convertMethodName = "AsCharEnumerable";
}
else if (sourceArrayElementType.IsInt16())
{
convertMethodName = "AsInt16Enumerable";
}
else if (sourceArrayElementType.IsUInt16())
{
convertMethodName = "AsUInt16Enumerable";
}
else if (sourceArrayElementType.IsInt32())
{
convertMethodName = "AsInt32Enumerable";
}
else if (sourceArrayElementType.IsUInt32())
{
convertMethodName = "AsUInt32Enumerable";
}
else if (sourceArrayElementType.IsInt64())
{
convertMethodName = "AsInt64Enumerable";
}
else if (sourceArrayElementType.IsFloat())
{
convertMethodName = "AsFloatEnumerable";
}
else if (sourceArrayElementType.IsDouble())
{
convertMethodName = "AsDoubleEnumerable";
}
else
{
throw new ArgumentOutOfRangeException("Unknown primitive array element type " + sourceArrayElementType);
}
}
return(convertMethodName);
}
/// <summary>
/// Convert a nullable .HasValue into.
/// </summary>
private static void ConvertEnumHasValue(AstExpression node, XTypeReference type, XModule data)
{
// Clear node
node.Code = AstCode.CIsNotNull;
node.Operand = null;
node.InferredType = data.TypeSystem.Bool;
node.ExpectedType = data.TypeSystem.Bool;
ConvertLoadArguments(node, type);
}
/// <summary>
/// Create a descriptor for comparing the given method without generics.
/// </summary>
private static string CreateNoGenericsDescriptor(XTypeReference type)
{
if (type.IsArray)
{
return(CreateNoGenericsDescriptor(((XArrayType)type).ElementType) + "[]");
}
XTypeDefinition typeDef;
return(type.TryResolve(out typeDef) ? typeDef.GetFullName(true) : type.GetFullName(true));
}
/// <summary>
/// Gets a class reference for the given type reference.
/// </summary>
internal static ClassReference GetClassReference(this XTypeReference type, DexTargetPackage targetPackage)
{
var classRef = type.GetReference(targetPackage) as ClassReference;
if (classRef == null)
{
throw new ArgumentException(string.Format("type {0} is not a class reference", type.FullName));
}
return(classRef);
}
/// <summary>
/// Create code to unbox the given source array of boxed type elements into an array of primitive elements.
/// </summary>
public static RLRange UnboxGenericArray(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec source, RegisterSpec boxedArray,
XTypeReference type, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler)
{
var internalBoxingType = compiler.GetDot42InternalType("Boxing").Resolve();
var ilUnboxMethod = internalBoxingType.Methods.First(x => x.EqualsName("UnboxTo") && (x.Parameters.Count == 2) && (x.Parameters[1].ParameterType.IsSame(type, true)));
var unboxMethod = ilUnboxMethod.GetReference(targetPackage);
var call = builder.Add(sequencePoint, RCode.Invoke_static, unboxMethod, boxedArray, source);
return(new RLRange(call, null));
}
/// <summary>
/// Gets the box information for the given type.
/// </summary>
private static BoxInfo Get(XTypeReference type)
{
var info = Infos.FirstOrDefault(x => type.Is(x.metadataType));
if (info != null)
{
return(info);
}
throw new ArgumentException(string.Format("No box information for for type {0}", type.FullName));
}
/// <summary>
/// Ensure that javaImportType is loaded.
/// </summary>
private void EnsureJavaImportType()
{
if (javaImportType == null)
{
// Load java import type
string className;
javaImportType = TryGetJavaImportNames(out className)
? Java.XBuilder.AsTypeReference(Module, className, XTypeUsageFlags.DeclaringType)
: Module.TypeSystem.NoType;
}
}
/// <summary>
/// Convert a nullable .HasValue into.
/// </summary>
private static void ConvertHasValue(AstExpression node, XTypeReference type, AstExpression target)
{
// Clear node
var originalArgs = node.Arguments.ToList();
node.Code = AstCode.CIsNotNull;
node.Operand = null;
node.Arguments.Clear();
AddLoadArgument(node, target, originalArgs[0]);
}
private static void Convert(AstExpression node, AstCode convertCode, XTypeReference expectedType)
{
// Copy load expression
var clone = new AstExpression(node);
// Convert node
node.Code = convertCode;
node.SetArguments(clone);
node.Operand = null;
node.SetType(expectedType);
}
/// <summary>
/// Default ctor
/// </summary>
private XSyntheticTypeDefinition(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType)
: base(module, declaringType, flags.HasFlag(XSyntheticTypeFlags.ValueType), null)
{
this.flags = flags;
this.@namespace = @namespace;
this.name = name;
this.baseType = baseType;
fields = new List<XFieldDefinition>();
methods = new List<XMethodDefinition>();
nestedTypes = new List<XTypeDefinition>();
interfaces = new List<XTypeReference>();
}
/// <summary>
/// Default ctor
/// </summary>
private XSyntheticTypeDefinition(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType)
: base(module, declaringType, flags.HasFlag(XSyntheticTypeFlags.ValueType), null)
{
this.flags = flags;
this.@namespace = @namespace;
this.name = name;
this.baseType = baseType;
fields = new List <XFieldDefinition>();
methods = new List <XMethodDefinition>();
nestedTypes = new List <XTypeDefinition>();
interfaces = new List <XTypeReference>();
}
/// <summary>
/// Create code to unbox the given source array of boxed type elements resulting from a call into an array of primitive elements.
/// </summary>
public static RLRange UnboxGenericArrayResult(this IRLBuilder builder, ISourceLocation sequencePoint, RegisterSpec boxedArray,
XTypeReference type, DexTargetPackage targetPackage, IRegisterAllocator frame, AssemblyCompiler compiler)
{
var internalBoxingType = compiler.GetDot42InternalType("Boxing").Resolve();
var primitiveArray = frame.AllocateTemp(type.GetReference(targetPackage));
var ilUnboxMethod = internalBoxingType.Methods.First(x => x.Name.StartsWith("Unbox") && (x.Parameters.Count == 1) && (x.ReturnType.IsSame(type, true)));
var unboxMethod = ilUnboxMethod.GetReference(targetPackage);
var call = builder.Add(sequencePoint, RCode.Invoke_static, unboxMethod, boxedArray);
var saveArray = builder.Add(sequencePoint, RCode.Move_result_object, primitiveArray);
return(new RLRange(call, saveArray, primitiveArray));
}
/// <summary>
/// Default ctor
/// </summary>
public JavaMethodReference(string name, bool hasThis, XTypeReference returnType, XTypeReference declaringType,
IEnumerable<XParameter> parameters, IEnumerable<string> genericParameterNames, string javaName, string javaDescriptor, string javaClassName)
: base(declaringType)
{
this.name = name;
this.hasThis = hasThis;
this.returnType = returnType;
this.javaName = javaName;
this.javaDescriptor = javaDescriptor;
this.javaClassName = javaClassName;
this.parameters = (parameters ?? Enumerable.Empty<XParameter>()).ToList().AsReadOnly();
genericParameters = (genericParameterNames ?? Enumerable.Empty<string>()).Select((x, i) => new XGenericParameter.SimpleXGenericParameter(this, i)).Cast<XGenericParameter>().ToList().AsReadOnly();
}
/// <summary>
/// Default ctor
/// </summary>
public ILMethodReference(XTypeReference declaringType, MethodReference method)
: base(declaringType)
{
this.method = method;
}
/// <summary>
/// Default ctor
/// </summary>
public XOptionalModifierType(XTypeReference modifierType, XTypeReference elementType)
: base(elementType)
{
this.modifierType = modifierType;
}
/// <summary>
/// Create a synthetic field and add it to the given declaring type.
/// </summary>
public static XSyntheticFieldDefinition Create(XTypeDefinition declaringType, XSyntheticFieldFlags flags, string name, XTypeReference fieldType, object initialValue = null)
{
var field = new XSyntheticFieldDefinition(declaringType, flags, name, fieldType, initialValue);
declaringType.Add(field);
return field;
}
/// <summary>
/// Convert an Java field reference to an XFieldReference.
/// </summary>
public static XFieldReference AsFieldReference(XModule module, string fieldName, string descriptor, XTypeReference declaringType, string className)
{
var fieldType = AsTypeReference(module, Descriptors.ParseFieldType(descriptor), XTypeUsageFlags.FieldType);
return new JavaFieldReference(fieldName, fieldType, declaringType, fieldName, descriptor, className);
}
/// <summary>
/// Convert an Java method reference to an XMethodReference.
/// </summary>
public static XMethodReference AsMethodReference(XModule module, string methodName, string descriptor, XTypeReference declaringType, string className, bool hasThis)
{
if (declaringType.IsArray)
{
declaringType = module.TypeSystem.Object;
}
var _descriptor = Descriptors.ParseMethodDescriptor(descriptor);
var returnType = AsTypeReference(module, _descriptor.ReturnType, XTypeUsageFlags.ReturnType);
var parameters = _descriptor.Parameters.Select((x, i) => new JavaParameter(module, "p" + i, x));
var name = methodName;
if (name == "<init>") name = ".ctor";
else if (name == "<clinit>") name = ".cctor";
return new JavaMethodReference(name, hasThis, returnType, declaringType, parameters, null, methodName, descriptor, className);
}
/// <summary>
/// Default ctor
/// </summary>
public XByReferenceType(XTypeReference elementType)
: base(elementType)
{
}
/// <summary>
/// Default ctor
/// </summary>
public XPointerType(XTypeReference elementType)
: base(elementType)
{
}
/// <summary>
/// Ensure that javaImportType is loaded.
/// </summary>
private void EnsureJavaImportType()
{
if (javaImportType == null)
{
// Load java import type
string className;
javaImportType = TryGetJavaImportNames(out className)
? Java.XBuilder.AsTypeReference(Module, className, XTypeUsageFlags.DeclaringType)
: Module.TypeSystem.NoType;
}
}
public static XParameter Create(string name, XTypeReference type)
{
return new TypedParameter(name, type);
}
/// <summary>
/// Create a synthetic field and add it to the given declaring type.
/// </summary>
public static XSyntheticTypeDefinition Create(XModule module, XTypeDefinition declaringType, XSyntheticTypeFlags flags, string @namespace, string name, XTypeReference baseType)
{
var type = new XSyntheticTypeDefinition(module, declaringType, flags, @namespace, name, baseType);
declaringType.Add(type);
return type;
}
/// <summary>
/// Create a System.Nullable<T> type with given T argument.
/// </summary>
private static XGenericInstanceType CreateNullableT(XModule module, XTypeReference argument)
{
return new XGenericInstanceType(new XTypeReference.SimpleXTypeReference(module, "System", "Nullable`1", null, true, new[] { "T" }), new[] { argument });
}
public TypedParameter(string name, XTypeReference type, XParameterKind kind = XParameterKind.Input)
: base(name, kind)
{
this.type = type;
}
/// <summary>
/// Default ctor
/// </summary>
public XRequiredModifierType(XTypeReference modifierType, XTypeReference elementType)
: base(elementType)
{
this.modifierType = modifierType;
}
/// <summary>
/// Does this type reference point to the same type as the given other reference?
/// </summary>
public override bool IsSame(XTypeReference other, bool ignoreSign)
{
if (base.IsSame(other, ignoreSign))
return true;
EnsureDexImportType();
if (dexImportType != Module.TypeSystem.NoType)
{
if (dexImportType.IsSame(other, ignoreSign))
return true;
}
EnsureJavaImportType();
if (javaImportType != Module.TypeSystem.NoType)
{
if (javaImportType.IsSame(other, ignoreSign))
return true;
}
return false;
}
