public class ILBlockTranslator {

public readonly AssemblyTranslator Translator;

public readonly DecompilerContext Context;

public readonly MethodReference ThisMethodReference;

public readonly MethodDefinition ThisMethod;

public readonly MethodSymbols Symbols;

public readonly ILBlock Block;

public readonly JavascriptFormatter Output = null;

public readonly Dictionary<string, JSVariable> Variables = new Dictionary<string, JSVariable>();

protected readonly Dictionary<ILVariable, JSVariable> RenamedVariables = new Dictionary<ILVariable, JSVariable>();

private readonly Dictionary<string, JSIndirectVariable> IndirectVariables = new Dictionary<string, JSIndirectVariable>();

public readonly SpecialIdentifiers SpecialIdentifiers;

public List<TypeReference> TemporaryVariableTypes = new List<TypeReference>();

protected int RenamedVariableCount = 0;

protected int UnlabelledBlockCount = 0;

protected int NextSwitchId = 0;

protected readonly Stack<bool> AutoCastingState = new Stack<bool>();

protected readonly Stack<JSStatement> Blocks = new Stack<JSStatement>();

static readonly ConcurrentCache<ILCode, System.Reflection.MethodInfo[]> NodeTranslatorCache = new ConcurrentCache<ILCode, System.Reflection.MethodInfo[]>();

static readonly ConcurrentCache<ILCode, System.Reflection.MethodInfo[]>.CreatorFunction GetNodeTranslatorsUncached;

protected readonly Func<TypeReference, TypeReference> TypeReferenceReplacer;

protected readonly IFunctionTransformer[] FunctionTransformers;

private readonly HashSet<TypeReference> _rawTypes;

static ILBlockTranslator () {

GetNodeTranslatorsUncached = (code) => {

var methodName = String.Format("Translate_{0}", code);

var bindingFlags = System.Reflection.BindingFlags.Instance |

System.Reflection.BindingFlags.InvokeMethod |

System.Reflection.BindingFlags.NonPublic;

var t = typeof(ILBlockTranslator);

var methods = t.GetMember(

methodName, MemberTypes.Method, bindingFlags

).OfType<System.Reflection.MethodInfo>().ToArray();

if (methods.Length == 0) {

var alternateMethodName = methodName.Substring(0, methodName.LastIndexOf("_"));

methods = t.GetMember(

alternateMethodName, MemberTypes.Method, bindingFlags

).OfType<System.Reflection.MethodInfo>().ToArray();

}

if (methods.Length == 0)

return null;

return methods;

};

}

public ILBlockTranslator (

AssemblyTranslator translator, DecompilerContext context,

MethodReference methodReference, MethodDefinition methodDefinition,

MethodSymbols methodSymbols,

ILBlock ilb, IEnumerable<ILVariable> parameters,

IEnumerable<ILVariable> allVariables,

Func<TypeReference, TypeReference> referenceReplacer = null

) {

Translator = translator;

Context = context;

ThisMethodReference = methodReference;

ThisMethod = methodDefinition;

Block = ilb;

TypeReferenceReplacer = referenceReplacer;

Symbols = methodSymbols;

SpecialIdentifiers = translator.GetSpecialIdentifiers(TypeSystem);

_rawTypes = new HashSet<TypeReference>

{

TypeSystem.Boolean,

TypeSystem.SByte,

TypeSystem.Byte,

TypeSystem.Int16,

TypeSystem.UInt16,

TypeSystem.Int32,

TypeSystem.UInt32,

TypeSystem.Single,

TypeSystem.Double,

TypeSystem.Char

};

if (methodReference.HasThis)

Variables.Add("this", JSThisParameter.New(methodReference.DeclaringType, methodReference));

foreach (var parameter in parameters) {

if ((parameter.Name == "this") && (parameter.OriginalParameter.Index == -1))

continue;

var jsp = new JSParameter(parameter.Name, parameter.Type, methodReference);

Variables.Add(jsp.Name, jsp);

}

foreach (var variable in allVariables) {

DeclareVariable(variable, methodReference);

}

var methodInfo = TypeInfo.Get(methodReference) as Internal.MethodInfo;

TypeReference packedArrayAttributeType;

var packedArrayArgumentNames = PackedArrayUtil.GetPackedArrayArgumentNames(methodInfo, out packedArrayAttributeType);

if (packedArrayArgumentNames != null)

foreach (var argumentName in packedArrayArgumentNames) {

if (!Variables.ContainsKey(argumentName))

throw new ArgumentException("JSPackedArrayArguments specifies an argument named '" + argumentName + "' but no such argument exists");

var variable = Variables[argumentName];

var newVariableType = PackedArrayUtil.MakePackedArrayType(variable.GetActualType(TypeSystem), packedArrayAttributeType);

if (newVariableType == null)

throw new ArgumentException("JSPackedArrayArguments specifies an argument named '" + argumentName + "' but it cannot be made a packed array");

ChangeVariableType(Variables[argumentName], newVariableType);

}

AutoCastingState.Push(true);

FunctionTransformers = Translator.FunctionTransformers;

}

protected TypeReference FixupReference (TypeReference reference) {

// TODO: Expand !N to actual generic parameter it references

if (TypeReferenceReplacer != null)

return TypeReferenceReplacer(reference);

else

return reference;

}

// When a method body is replaced by the body of a proxy method, the method body

// will contain references to members of the proxy class instead of the class being

// proxied. We correct those references to point to the class being proxied (via

// a call to FixupReference) before doing MemberInfo lookups.

protected T GetMember<T> (MemberReference member)

where T : class, IMemberInfo

{

var declaringType = member.DeclaringType;

declaringType = FixupReference(declaringType);

var typeInfo = TypeInfo.Get(declaringType);

if (typeInfo == null) {

Console.Error.WriteLine("Warning: type not loaded: {0}", declaringType.FullName);

return default(T);

}

var identifier = MemberIdentifier.New(TypeInfo, member);

IMemberInfo result;

if (!typeInfo.Members.TryGetValue(identifier, out result)) {

// Console.Error.WriteLine("Warning: member not defined: {0}", member.FullName);

return default(T);

}

return result as T;

}

protected JSIL.Internal.MethodInfo GetMethod (MethodReference method) {

return GetMember<JSIL.Internal.MethodInfo>(method);

}

protected JSIL.Internal.FieldInfo GetField (FieldReference field) {

return GetMember<JSIL.Internal.FieldInfo>(field);

}

internal MethodTypeFactory MethodTypes {

get {

return Translator.FunctionCache.MethodTypes;

}

}

protected JSSpecialIdentifiers JS {

get {

return SpecialIdentifiers.JS;

}

}

protected JSILIdentifier JSIL {

get {

return SpecialIdentifiers.JSIL;

}

}

public ITypeInfoSource TypeInfo {

get {

return Translator.TypeInfoProvider;

}

}

public TypeSystem TypeSystem {

get {

return Context.CurrentModule.TypeSystem;

}

}

public JSBlockStatement Translate () {

try {

return TranslateNode(Block);

} catch (AbortTranslation at) {

Translator.WarningFormat("Method {0} not translated: {1}", ThisMethod.Name, at.Message);

return null;

}

}

public JSNode TranslateNode (ILNode node) {

Translator.WarningFormat("Node NYI: {0}", node.GetType().Name);

return new JSUntranslatableStatement(node.GetType().Name);

}

public List<JSExpression> Translate (IList<ILExpression> values, IList<ParameterDefinition> parameters, bool hasThis) {

var result = new List<JSExpression>();

ParameterDefinition parameter;

for (int i = 0, c = values.Count; i < c; i++) {

var value = values[i];

var parameterIndex = i;

if (hasThis)

parameterIndex -= 1;

if ((parameterIndex < parameters.Count) && (parameterIndex >= 0))

parameter = parameters[parameterIndex];

else

parameter = null;

var translated = TranslateNode(value);

if ((parameter != null) && (parameter.ParameterType is ByReferenceType)) {

result.Add(new JSPassByReferenceExpression(translated));

} else

result.Add(translated);

}

if (result.Any((je) => je == null)) {

var errorString = new StringBuilder();

errorString.AppendLine("The following expressions failed to translate:");

for (var i = 0; i < values.Count; i++) {

if (result[i] == null)

errorString.AppendLine(values[i].ToString());

}

throw new InvalidDataException(errorString.ToString());

}

return result;

}

public List<JSExpression> Translate (IEnumerable<ILExpression> values) {

var result = new List<JSExpression>();

StringBuilder errorString = null;

foreach (var value in values) {

var translated = TranslateNode(value);

if (translated == null) {

if (errorString == null) {

errorString = new StringBuilder();

errorString.AppendLine("The following expressions failed to translate:");

}

errorString.AppendLine(value.ToString());

} else {

result.Add(translated);

}

}

if (errorString != null)

throw new InvalidDataException(errorString.ToString());

return result;

}

protected bool NeedToRenameVariable (string name, TypeReference type) {

if (String.IsNullOrWhiteSpace(name))

return true;

if (!Variables.ContainsKey(name))

return false;

if (!TypeUtil.TypesAreEqual(Variables[name].IdentifierType, type))

return true;

return false;

}

protected JSVariable DeclareVariable (ILVariable variable, MethodReference function) {

if (variable.Name.StartsWith("<>c__")) {

return DeclareVariableInternal(JSClosureVariable.New(variable, function));

}

var name = variable.Name;

if (NeedToRenameVariable(name, variable.Type)) {

if (!NeedToRenameVariable(variable.OriginalVariable.Name, variable.Type))

name = variable.OriginalVariable.Name;

else

name = String.Format("{0}${1}", name, RenamedVariableCount++);

}

var result = JSVariable.New(name, variable.Type, function);

return DeclareVariableInternal(result);

}

protected JSVariable DeclareVariableInternal (JSVariable variable) {

JSVariable existing;

if (Variables.TryGetValue(variable.Identifier, out existing)) {

if (!TypeUtil.TypesAreEqual(variable.IdentifierType, existing.IdentifierType)) {

throw new InvalidOperationException(String.Format(

"A variable with the name '{0}' is already declared in this scope, with a different type.",

variable.Identifier

));

} else if (!variable.DefaultValue.Equals(existing.DefaultValue)) {

throw new InvalidOperationException(String.Format(

"A variable with the name '{0}' is already declared in this scope, with a different default value.",

variable.Identifier

));

}

return existing;

}

Variables[variable.Identifier] = variable;

return variable;

}

protected static bool CopyOnReturn (TypeReference type) {

return TypeUtil.IsStruct(type);

}

protected JSExpression Translate_UnaryOp (ILExpression node, JSUnaryOperator op) {

var inner = TranslateNode(node.Arguments[0]);

var innerType = JSExpression.DeReferenceType(inner.GetActualType(TypeSystem));

// Detect the weird pattern '!(x = y as z)' and transform it into '(x = y as z) != null'

if (

(op == JSOperator.LogicalNot) &&

!TypeUtil.TypesAreAssignable(TypeInfo, TypeSystem.Boolean, innerType)

) {

return new JSBinaryOperatorExpression(

JSOperator.Equal, inner, new JSDefaultValueLiteral(innerType), TypeSystem.Boolean

);

}

// Insert correct casts when unary operators are applied to enums.

if (TypeUtil.IsEnum(innerType) && TypeUtil.IsEnum(node.InferredType ?? node.ExpectedType)) {

return JSCastExpression.New(

new JSUnaryOperatorExpression(

op,

JSCastExpression.New(inner, TypeSystem.Int32, TypeSystem),

TypeSystem.Int32

),

node.InferredType ?? node.ExpectedType, TypeSystem

);

}

return new JSUnaryOperatorExpression(

op, inner, node.InferredType ?? node.ExpectedType

);

}

public static bool ShouldSuppressAutoCastingForOperator (JSOperator op) {

return (op is JSComparisonOperator);

}

protected JSExpression Translate_BinaryOp_Pointer (ILExpression node, JSBinaryOperator op, JSExpression lhs, JSExpression rhs) {

if ((lhs is JSUntranslatableExpression) || (rhs is JSUntranslatableExpression))

return new JSUntranslatableExpression(node);

// We can end up with a pointer literal in an arithmetic expression.

// In this case we want to switch it back to a normal integer literal so that the math operations work.

var leftPointer = lhs as JSPointerLiteral;

var rightPointer = rhs as JSPointerLiteral;

if (!(op is JSAssignmentOperator)) {

if (leftPointer != null)

lhs = new JSNativeIntegerLiteral((int)leftPointer.Value);

if (rightPointer != null)

rhs = new JSNativeIntegerLiteral((int)rightPointer.Value);

}

var leftCast = lhs as JSPointerCastExpression;

var rightCast = rhs as JSPointerCastExpression;

// HACK: IL sometimes does (T*)((UInt64)lhs + (UInt64)rhs). Strip the conversions so we can make sense of it

if (

(leftCast != null) &&

TypeUtil.IsIntegral(leftCast.NewType.Type)

)

lhs = leftCast.Pointer;

if (

(rightCast != null) &&

TypeUtil.IsIntegral(rightCast.NewType.Type)

)

rhs = rightCast.Pointer;

var leftType = lhs.GetActualType(TypeSystem);

var rightType = rhs.GetActualType(TypeSystem);

var leftIsNativeInt = TypeUtil.IsNativeInteger(leftType);

var rightIsNativeInt = TypeUtil.IsNativeInteger(rightType);

var leftIsPointerish = TypeUtil.IsPointer(leftType) || leftIsNativeInt;

var rightIsPointerish = TypeUtil.IsPointer(rightType) || rightIsNativeInt;

JSExpression result = null;

if (leftIsPointerish && TypeUtil.IsIntegral(rightType)) {

if (

(op == JSOperator.Add) ||

(op == JSOperator.AddAssignment)

) {

result = new JSPointerAddExpression(

lhs, rhs,

op == JSOperator.AddAssignment

);

} else if (

(op == JSOperator.Subtract) ||

(op == JSOperator.SubtractAssignment)

) {

result = new JSPointerAddExpression(

lhs,

new JSUnaryOperatorExpression(JSOperator.Negation, rhs, TypeSystem.NativeInt()),

op == JSOperator.SubtractAssignment

);

} else if (

(op == JSOperator.Divide) ||

(op == JSOperator.DivideAssignment)

) {

// This should only happen when the lhs is already a native int

if (TypeUtil.IsPointer(leftType))

return new JSUntranslatableExpression(node);

result = new JSBinaryOperatorExpression(

op, lhs, rhs, TypeSystem.NativeInt()

);

} else if (

op is JSComparisonOperator

) {

if (!TypeUtil.IsPointer(leftType))

return new JSUntranslatableExpression(node);

result = new JSBinaryOperatorExpression(

op,

new JSDotExpression(lhs, new JSStringIdentifier("offsetInBytes", TypeSystem.Int32, true)),

rhs,

TypeSystem.Boolean

);

} else {

// TODO: Implement ptr * <native-int>

// TODO: Implement ptr & <mask>

if (Debugger.IsAttached) {

Console.WriteLine("Debugger.Break()");

Console.Error.WriteLine("Debugger.Break()");

// Debugger.Break();

}

}

} else if (leftIsPointerish && rightIsPointerish) {

if (op == JSOperator.Subtract) {

result = new JSPointerDeltaExpression(

lhs, rhs, TypeSystem.NativeInt()

);

} else if (op is JSComparisonOperator) {

result = new JSPointerComparisonExpression(op, lhs, rhs, TypeSystem.Boolean);

} else if ((op == JSOperator.Add) && (leftIsNativeInt || rightIsNativeInt)) {

if (leftIsNativeInt)

return new JSPointerAddExpression(rhs, lhs, false);

else /* if (rightIsNativeInt) */

return new JSPointerAddExpression(lhs, rhs, false);

} else {

if (Debugger.IsAttached) {

Console.WriteLine("Debugger.Break()");

Console.Error.WriteLine("Debugger.Break()");

// Debugger.Break();

}

}

}

if (result == null)

return new JSUntranslatableExpression(node);

else

return result;

}

protected JSExpression Translate_BinaryOp (ILExpression node, JSBinaryOperator op) {

// Detect attempts to perform pointer arithmetic

if (TypeUtil.IsIgnoredType(node.Arguments[0].ExpectedType) ||

TypeUtil.IsIgnoredType(node.Arguments[1].ExpectedType) ||

TypeUtil.IsIgnoredType(node.Arguments[0].InferredType) ||

TypeUtil.IsIgnoredType(node.Arguments[1].InferredType)

) {

return new JSUntranslatableExpression(node);

}

// Detect attempts to perform pointer arithmetic on a local variable.

// (ldloca produces a reference, not a pointer, so the previous check won't catch this.)

if (

(node.Arguments[0].Code == ILCode.Ldloca) &&

!(op is JSAssignmentOperator)

)

return new JSUntranslatableExpression(node);

// HACK: Auto-casting for pointer arithmetic is undesirable, because ILSpy

// infers incorrect types here

var arePointersInvolved =

TypeUtil.IsPointer(TypeUtil.DereferenceType(node.Arguments[0].ExpectedType)) ||

TypeUtil.IsPointer(TypeUtil.DereferenceType(node.Arguments[0].InferredType)) ||

TypeUtil.IsPointer(TypeUtil.DereferenceType(node.Arguments[1].ExpectedType)) ||

TypeUtil.IsPointer(TypeUtil.DereferenceType(node.Arguments[1].InferredType));

JSExpression lhs, rhs;

AutoCastingState.Push(

!ShouldSuppressAutoCastingForOperator(op) &&

!arePointersInvolved

);

try {

lhs = TranslateNode(node.Arguments[0]);

rhs = TranslateNode(node.Arguments[1]);

} finally {

AutoCastingState.Pop();

}

if (TypeUtil.IsPointer(lhs.GetActualType(TypeSystem)))

arePointersInvolved |= true;

else if (TypeUtil.IsPointer(rhs.GetActualType(TypeSystem)))

arePointersInvolved |= true;

var boeLeft = lhs as JSBinaryOperatorExpression;

if (

(op is JSAssignmentOperator) &&

(boeLeft != null) && !(boeLeft.Operator is JSAssignmentOperator)

)

return new JSUntranslatableExpression(node);

if (arePointersInvolved)

return Translate_BinaryOp_Pointer(node, op, lhs, rhs);

var resultType = node.InferredType ?? node.ExpectedType;

var leftType = lhs.GetActualType(TypeSystem);

var rightType = rhs.GetActualType(TypeSystem);

if (

TypeUtil.IsIntegral(leftType) &&

TypeUtil.IsIntegral(rightType) &&

TypeUtil.IsIntegral(resultType) &&

!(op is JSBitwiseOperator)

) {

// HACK: Compensate for broken ILSpy type inference on certain forms of integer arithmetic

var sizeofLeft = TypeUtil.SizeOfType(leftType);

var sizeofRight = TypeUtil.SizeOfType(rightType);

TypeReference largestType;

if (sizeofLeft > sizeofRight)

largestType = leftType;

else

largestType = rightType;

var sizeofInferred = (node.InferredType != null) && TypeUtil.IsIntegral(node.InferredType)

? TypeUtil.SizeOfType(node.InferredType)

: 0;

var sizeofExpected = (node.ExpectedType != null) && TypeUtil.IsIntegral(node.ExpectedType)

? TypeUtil.SizeOfType(node.ExpectedType)

: 0;

if (TypeUtil.SizeOfType(largestType) > Math.Max(sizeofInferred, sizeofExpected)) {

// FIXME: Get the sign right?

resultType = largestType;

}

}

var result = new JSBinaryOperatorExpression(

op, lhs, rhs, resultType

);

return result;

}

protected JSExpression HandleJSReplacement (

MethodReference method, Internal.MethodInfo methodInfo,

JSExpression thisExpression, JSExpression[] arguments,

TypeReference resultType, bool explicitThis

) {

foreach (var transformer in FunctionTransformers) {

var externalReplacement = transformer.MaybeReplaceMethodCall(

ThisMethodReference,

method, methodInfo,

thisExpression, arguments,

resultType, explicitThis

);

if (externalReplacement != null)

return externalReplacement;

}

var metadata = methodInfo.Metadata;

if (metadata != null) {

var parms = metadata.GetAttributeParameters("JSIL.Meta.JSReplacement");

if (parms != null) {

var argsDict = new Dictionary<string, JSExpression>();

argsDict["assemblyof(executing)"] = new JSReflectionAssembly(ThisMethod.DeclaringType.Module.Assembly);

if (methodInfo.IsStatic) {

argsDict["this"] = new JSNullLiteral(TypeSystem.Object);

argsDict["typeof(this)"] = Translate_TypeOf(methodInfo.DeclaringType.Definition);

argsDict["etypeof(this)"] = Translate_TypeOf(methodInfo.DeclaringType.Definition.GetElementType());

argsDict["declaringType(method)"] = Translate_TypeOf(methodInfo.DeclaringType.Definition);

argsDict["explicitThis(method)"] = new JSBooleanLiteral(false);

}

else if (thisExpression != null)

{

argsDict["this"] = thisExpression;

argsDict["typeof(this)"] = Translate_TypeOf(thisExpression.GetActualType(TypeSystem));

argsDict["etypeof(this)"] = Translate_TypeOf(thisExpression.GetActualType(TypeSystem).GetElementType());

argsDict["this"] = thisExpression;

argsDict["declaringType(method)"] = Translate_TypeOf(methodInfo.DeclaringType.Definition);

argsDict["explicitThis(method)"] = new JSBooleanLiteral(explicitThis);

}

var genericMethod = method as GenericInstanceMethod;

if (genericMethod != null) {

foreach (var kvp in methodInfo.GenericParameterNames.Zip(genericMethod.GenericArguments, (n, p) => new { Name = n, Value = p })) {

argsDict.Add(kvp.Name, new JSTypeOfExpression(kvp.Value));

}

}

foreach (var kvp in methodInfo.Parameters.Zip(arguments, (p, v) => new { p.Name, Value = v })) {

argsDict.Add(kvp.Name, kvp.Value);

var type = kvp.Value.GetActualType(TypeSystem);

argsDict["typeof(" + kvp.Name + ")"] = Translate_TypeOf(type);

var typeSpecification = type as TypeSpecification;

argsDict["etypeof(" + kvp.Name + ")"] = Translate_TypeOf(typeSpecification != null ? typeSpecification.ElementType : type.GetElementType());

}

var isConstantIfArgumentsAre = methodInfo.Metadata.HasAttribute("JSIL.Meta.JSIsPure");

var result = new JSVerbatimLiteral(

method.Name, (string)parms[0].Value, argsDict, resultType, isConstantIfArgumentsAre

);

return PackedArrayUtil.FilterInvocationResult(

method, methodInfo,

result,

TypeInfo, TypeSystem

);

}

}

return null;

}

protected JSExpression Translate_ConstructorReplacement (

MethodReference constructor, Internal.MethodInfo constructorInfo, JSNewExpression newExpression

) {

var instanceType = newExpression.GetActualType(TypeSystem);

var jsr = HandleJSReplacement(

constructor, constructorInfo, new JSNullLiteral(instanceType), newExpression.Arguments.ToArray(),

instanceType, false

);

if (jsr != null)

return jsr;

return newExpression;

}

private JSIndirectVariable MakeIndirectVariable (string name) {

JSIndirectVariable result;

if (!IndirectVariables.TryGetValue(name, out result))

IndirectVariables.Add(name, result = new JSIndirectVariable(Variables, name, ThisMethodReference));

return result;

}

internal JSExpression DoMethodReplacement (

JSMethod method, JSExpression thisExpression,

JSExpression[] arguments, bool @virtual, bool @static, bool explicitThis, bool suppressThisClone

) {

var methodInfo = method.Method;

PackedArrayUtil.CheckInvocationSafety(method.Method, arguments, TypeSystem);

bool retry;

do {

retry = false;

var metadata = methodInfo.Metadata;

if (metadata != null) {

var jsr = HandleJSReplacement(

method.Reference, methodInfo, thisExpression, arguments,

method.Reference.ReturnType, explicitThis

);

if (jsr != null)

return jsr;

// Proxy method bodies can call other methods declared on the proxy

// that are actually stand-ins for methods declared on the proxied type.

if (

metadata.HasAttribute("JSIL.Proxy.JSNeverReplace") &&

!TypeUtil.TypesAreEqual(method.Reference.DeclaringType, methodInfo.DeclaringType.Definition) &&

!methodInfo.DeclaringType.IsProxy

) {

var proxyTypeInfo = TypeInfo.GetExisting(method.Reference.DeclaringType);

if ((proxyTypeInfo != null) && proxyTypeInfo.IsProxy) {

var originalMethod =

(from m in methodInfo.DeclaringType.Definition.Methods

let mi = TypeInfo.GetMethod(m)

where (mi != null) &&

mi.NamedSignature.Equals(methodInfo.NamedSignature)

select m).FirstOrDefault();

if (originalMethod != null) {

methodInfo = TypeInfo.GetMethod(originalMethod);

method = new JSMethod(originalMethod, methodInfo, method.MethodTypes, method.GenericArguments);

retry = true;

}

}

}

}

} while (retry);

if (methodInfo.IsIgnored)

return new JSIgnoredMemberReference(true, methodInfo, new[] { thisExpression }.Concat(arguments).ToArray());

JSExpression result = DoNonJSILMethodReplacement(method, arguments);

if (result != null)

return result;

result = DoJSILMethodReplacement(

method.Method.DeclaringType.FullName,

method.Method.Name,

method,

method.GenericArguments,

arguments

);

if (result != null)

return result;

result = Translate_PropertyCall(thisExpression, method, arguments, @virtual, @static);

if (result == null) {

if (@static)

result = JSInvocationExpression.InvokeStatic(method.Reference.DeclaringType, method, arguments);

else if (explicitThis)

result = JSInvocationExpression.InvokeBaseMethod(method.Reference.DeclaringType, method, thisExpression, arguments);