| public abstract BranchIfNotEqual ( ILLabel label ) : void | ||
| label | ILLabel | The label to branch to. |
| return | void | |
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
{
generator.LoadInt32((int)this.Value);
}
else if (this.Value is double)
{
generator.LoadDouble((double)this.Value);
}
else if (this.Value is string)
{
generator.LoadString((string)this.Value);
}
else if (this.Value is bool)
{
generator.LoadBoolean((bool)this.Value);
}
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List <Expression> )
{
// Construct an array literal.
var arrayLiteral = (List <Expression>) this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
{
generator.LoadNull();
}
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New);
}
else if (this.Value is List <KeyValuePair <Expression, Expression> > )
{
// This is an object literal.
var properties = (List <KeyValuePair <Expression, Expression> >) this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
foreach (var keyValuePair in properties)
{
Expression propertyName = keyValuePair.Key;
Expression propertyValue = keyValuePair.Value;
generator.Duplicate();
// The key can be a property name or an expression that evaluates to a name.
propertyName.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, propertyName.ResultType);
var functionValue = propertyValue as FunctionExpression;
if (functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Getter)
{
// Add a getter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
functionValue.GenerateDisplayName(generator, optimizationInfo, "get " + (string)((LiteralExpression)propertyName).Value, true);
}
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralGetter);
}
else if (functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Setter)
{
// Add a setter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
functionValue.GenerateDisplayName(generator, optimizationInfo, "set " + (string)((LiteralExpression)propertyName).Value, true);
}
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralSetter);
}
else
{
// Add a new property to the object.
propertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyValue is FunctionExpression && propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
((FunctionExpression)propertyValue).GenerateDisplayName(generator, optimizationInfo, (string)((LiteralExpression)propertyName).Value, false);
}
EmitConversion.ToAny(generator, propertyValue.ResultType);
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralValue);
}
}
}
else
{
throw new NotImplementedException("Unknown literal type.");
}
}
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
{
generator.LoadInt32((int)this.Value);
}
else if (this.Value is double)
{
generator.LoadDouble((double)this.Value);
}
else if (this.Value is string)
{
generator.LoadString((string)this.Value);
}
else if (this.Value is bool)
{
generator.LoadBoolean((bool)this.Value);
}
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List <Expression> )
{
// Construct an array literal.
var arrayLiteral = (List <Expression>) this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
{
generator.LoadNull();
}
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New);
}
else if (this.Value is Dictionary <string, object> )
{
// This is an object literal.
var properties = (Dictionary <string, object>) this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
foreach (var keyValuePair in properties)
{
string propertyName = keyValuePair.Key;
object propertyValue = keyValuePair.Value;
generator.Duplicate();
generator.LoadString(propertyName);
if (propertyValue is Expression)
{
// Add a new property to the object.
var dataPropertyValue = (Expression)propertyValue;
dataPropertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (dataPropertyValue is FunctionExpression)
{
((FunctionExpression)dataPropertyValue).GenerateDisplayName(generator, optimizationInfo, propertyName, false);
}
EmitConversion.ToAny(generator, dataPropertyValue.ResultType);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_String);
}
else if (propertyValue is Parser.ObjectLiteralAccessor)
{
// Add a new getter/setter to the object.
var accessorValue = (Parser.ObjectLiteralAccessor)propertyValue;
if (accessorValue.Getter != null)
{
accessorValue.Getter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Getter.GenerateDisplayName(generator, optimizationInfo, "get " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Getter.ResultType);
}
else
{
generator.LoadNull();
}
if (accessorValue.Setter != null)
{
accessorValue.Setter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Setter.GenerateDisplayName(generator, optimizationInfo, "set " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Setter.ResultType);
}
else
{
generator.LoadNull();
}
generator.LoadInt32((int)Library.PropertyAttributes.FullAccess);
generator.NewObject(ReflectionHelpers.PropertyDescriptor_Constructor3);
generator.LoadBoolean(false);
generator.Call(ReflectionHelpers.ObjectInstance_DefineProperty);
generator.Pop();
}
else
{
throw new InvalidOperationException("Invalid property value type in object literal.");
}
}
}
else
{
throw new NotImplementedException("Unknown literal type.");
}
}
/// <summary>
/// Generates IL for the script.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
protected override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Method signature: object FunctionDelegate(Compiler.Scope scope, object thisObject, Library.FunctionInstance functionObject, object[] arguments)
// Initialize the scope (note: the initial scope for a function is always declarative).
this.BaseScope.GenerateScopeCreation(generator, optimizationInfo);
// In ES3 the "this" value must be an object. See 10.4.3 in the spec.
if (this.StrictMode == false && this.MethodOptimizationHints.HasThis == true)
{
// context.ConvertThisToObject();
EmitHelpers.LoadExecutionContext(generator);
generator.Call(ReflectionHelpers.ExecutionContext_ConvertThisToObject);
}
// Transfer the function name into the scope.
if (Name.HasStaticName && !Name.IsGetter && !Name.IsSetter &&
this.Arguments.Any(a => a.Name == Name.StaticName) == false &&
optimizationInfo.MethodOptimizationHints.HasVariable(Name.StaticName))
{
EmitHelpers.LoadFunction(generator);
var functionName = new NameExpression(this.BaseScope, Name.StaticName);
functionName.GenerateSet(generator, optimizationInfo, PrimitiveType.Any);
}
// Transfer the arguments object into the scope.
if (this.MethodOptimizationHints.HasArguments == true && this.Arguments.Any(a => a.Name == "arguments") == false)
{
// executionContext.CreateArgumentsInstance(object[] arguments)
EmitHelpers.LoadExecutionContext(generator);
this.BaseScope.GenerateReference(generator, optimizationInfo);
EmitHelpers.LoadArgumentsArray(generator);
generator.Call(ReflectionHelpers.ExecutionContext_CreateArgumentsInstance);
var arguments = new NameExpression(this.BaseScope, "arguments");
arguments.GenerateSet(generator, optimizationInfo, PrimitiveType.Any);
}
// Transfer the argument values into the scope.
// Note: the arguments array can be smaller than expected.
if (this.Arguments.Count > 0)
{
for (int i = 0; i < this.Arguments.Count; i++)
{
// Check if a duplicate argument name exists.
bool duplicate = false;
for (int j = i + 1; j < this.Arguments.Count; j++)
{
if (this.Arguments[i].Name == this.Arguments[j].Name)
{
duplicate = true;
break;
}
}
if (duplicate == true)
{
continue;
}
var loadDefaultValue = generator.CreateLabel();
var storeValue = generator.CreateLabel();
// Check if an array element exists.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadArrayLength();
generator.LoadInt32(i);
generator.BranchIfLessThanOrEqual(loadDefaultValue);
// Load the parameter value from the parameters array.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadInt32(i);
generator.LoadArrayElement(typeof(object));
if (this.Arguments[i].DefaultValue == null)
{
// Branch to the part where it stores the value.
generator.Branch(storeValue);
// Load undefined.
generator.DefineLabelPosition(loadDefaultValue);
EmitHelpers.EmitUndefined(generator);
generator.ReinterpretCast(typeof(object));
}
else
{
// Check if it's undefined.
generator.Duplicate();
EmitHelpers.EmitUndefined(generator);
generator.ReinterpretCast(typeof(object));
generator.BranchIfNotEqual(storeValue);
generator.Pop();
// Load the default value.
generator.DefineLabelPosition(loadDefaultValue);
this.Arguments[i].DefaultValue.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Arguments[i].DefaultValue.ResultType);
}
// Store the value in the scope.
generator.DefineLabelPosition(storeValue);
var argument = new NameExpression(this.BaseScope, this.Arguments[i].Name);
argument.GenerateSet(generator, optimizationInfo, PrimitiveType.Any);
}
}
// Initialize any declarations.
this.BaseScope.GenerateHoistedDeclarations(generator, optimizationInfo);
// Generate code for the body of the function.
this.AbstractSyntaxTree.GenerateCode(generator, optimizationInfo);
// Define the return target - this is where the return statement jumps to.
// ReturnTarget can be null if there were no return statements.
if (optimizationInfo.ReturnTarget != null)
{
generator.DefineLabelPosition(optimizationInfo.ReturnTarget);
}
// Load the return value. If the variable is null, there were no return statements.
if (optimizationInfo.ReturnVariable != null)
{
// Return the value stored in the variable. Will be null if execution hits the end
// of the function without encountering any return statements.
generator.LoadVariable(optimizationInfo.ReturnVariable);
}
else
{
// There were no return statements - return null.
generator.LoadNull();
}
}
/// <summary>
/// Generates a method that does type conversion and calls the bound method.
/// </summary>
/// <param name="generator"> The ILGenerator used to output the body of the method. </param>
/// <param name="argumentCount"> The number of arguments that will be passed to the delegate. </param>
/// <returns> A delegate that does type conversion and calls the method represented by this
/// object. </returns>
protected override void GenerateStub(ILGenerator generator, int argumentCount)
{
// Determine the methods that have the correct number of arguments.
var candidateMethods = new List<BinderMethod>();
foreach (var candidateMethod in this.targetMethods)
{
if (candidateMethod.IsArgumentCountCompatible(argumentCount) == true)
candidateMethods.Add(candidateMethod);
}
// Zero candidates means no overload had the correct number of arguments.
if (candidateMethods.Count == 0)
{
EmitHelpers.EmitThrow(generator, "TypeError", string.Format("No overload for method '{0}' takes {1} arguments", this.Name, argumentCount));
EmitHelpers.EmitDefaultValue(generator, PrimitiveType.Any);
generator.Complete();
return;
}
// Select the method to call at run time.
generator.LoadInt32(candidateMethods.Count);
generator.NewArray(typeof(RuntimeMethodHandle));
for (int i = 0; i < candidateMethods.Count; i ++)
{
generator.Duplicate();
generator.LoadInt32(i);
generator.LoadToken(candidateMethods[i]);
generator.StoreArrayElement(typeof(RuntimeMethodHandle));
}
generator.LoadArgument(0);
generator.LoadArgument(1);
generator.LoadArgument(2);
generator.Call(ReflectionHelpers.BinderUtilities_ResolveOverloads);
var endOfMethod = generator.CreateLabel();
for (int i = 0; i < candidateMethods.Count; i++)
{
// Check if this is the selected method.
ILLabel endOfIf = null;
if (i < candidateMethods.Count - 1)
{
generator.Duplicate();
generator.LoadInt32(i);
endOfIf = generator.CreateLabel();
generator.BranchIfNotEqual(endOfIf);
}
generator.Pop();
var targetMethod = candidateMethods[i];
// Convert the arguments.
foreach (var argument in targetMethod.GenerateArguments(generator, argumentCount))
{
// Load the input parameter value.
switch (argument.Source)
{
case BinderArgumentSource.ScriptEngine:
generator.LoadArgument(0);
break;
case BinderArgumentSource.ThisValue:
generator.LoadArgument(1);
break;
case BinderArgumentSource.InputParameter:
generator.LoadArgument(2);
generator.LoadInt32(argument.InputParameterIndex);
generator.LoadArrayElement(typeof(object));
break;
}
// Convert to the target type.
EmitConversionToType(generator, argument.Type, convertToAddress: argument.Source == BinderArgumentSource.ThisValue);
}
// Call the target method.
targetMethod.GenerateCall(generator);
// Convert the return value.
if (targetMethod.ReturnType == typeof(void))
EmitHelpers.EmitUndefined(generator);
else
EmitConversionToObject(generator, targetMethod.ReturnType);
// Branch to the end of the method if this was the selected method.
if (endOfIf != null)
{
generator.Branch(endOfMethod);
generator.DefineLabelPosition(endOfIf);
}
}
generator.DefineLabelPosition(endOfMethod);
generator.Complete();
}
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
generator.LoadInt32((int)this.Value);
else if (this.Value is double)
generator.LoadDouble((double)this.Value);
else if (this.Value is string)
generator.LoadString((string)this.Value);
else if (this.Value is bool)
generator.LoadBoolean((bool)this.Value);
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List<Expression>)
{
// Construct an array literal.
var arrayLiteral = (List<Expression>)this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i ++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
generator.LoadNull();
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New);
}
else if (this.Value is Dictionary<string, object>)
{
// This is an object literal.
var properties = (Dictionary<string, object>)this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
foreach (var keyValuePair in properties)
{
string propertyName = keyValuePair.Key;
object propertyValue = keyValuePair.Value;
generator.Duplicate();
generator.LoadString(propertyName);
if (propertyValue is Expression)
{
// Add a new property to the object.
var dataPropertyValue = (Expression)propertyValue;
dataPropertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (dataPropertyValue is FunctionExpression)
((FunctionExpression)dataPropertyValue).GenerateDisplayName(generator, optimizationInfo, propertyName, false);
EmitConversion.ToAny(generator, dataPropertyValue.ResultType);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_String);
}
else if (propertyValue is Parser.ObjectLiteralAccessor)
{
// Add a new getter/setter to the object.
var accessorValue = (Parser.ObjectLiteralAccessor)propertyValue;
if (accessorValue.Getter != null)
{
accessorValue.Getter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Getter.GenerateDisplayName(generator, optimizationInfo, "get " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Getter.ResultType);
}
else
generator.LoadNull();
if (accessorValue.Setter != null)
{
accessorValue.Setter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Setter.GenerateDisplayName(generator, optimizationInfo, "set " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Setter.ResultType);
}
else
generator.LoadNull();
generator.LoadInt32((int)Library.PropertyAttributes.FullAccess);
generator.NewObject(ReflectionHelpers.PropertyDescriptor_Constructor3);
generator.LoadBoolean(false);
generator.Call(ReflectionHelpers.ObjectInstance_DefineProperty);
generator.Pop();
}
else
throw new InvalidOperationException("Invalid property value type in object literal.");
}
}
else
throw new NotImplementedException("Unknown literal type.");
}
/// <summary>
/// Pops the value on the stack, converts it from an object to the given type, then pushes
/// the result onto the stack.
/// </summary>
/// <param name="generator"> The IL generator. </param>
/// <param name="toType"> The type to convert to. </param>
/// <param name="convertToAddress"> <c>true</c> if the value is intended for use as an
/// instance pointer; <c>false</c> otherwise. </param>
internal static void EmitConversionToType(ILGenerator generator, Type toType, bool convertToAddress)
{
// Convert Null.Value to null if the target type is a reference type.
ILLabel endOfNullCheck = null;
if (toType.IsValueType == false)
{
var startOfElse = generator.CreateLabel();
endOfNullCheck = generator.CreateLabel();
generator.Duplicate();
EmitHelpers.EmitNull(generator);
generator.BranchIfNotEqual(startOfElse);
generator.Pop();
generator.LoadNull();
generator.Branch(endOfNullCheck);
generator.DefineLabelPosition(startOfElse);
}
switch (Type.GetTypeCode(toType))
{
case TypeCode.Boolean:
EmitConversion.ToBool(generator, PrimitiveType.Any);
break;
case TypeCode.Byte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Char:
EmitConversion.ToString(generator, PrimitiveType.Any);
generator.Duplicate();
generator.Call(ReflectionHelpers.String_Length);
generator.LoadInt32(1);
var endOfCharCheck = generator.CreateLabel();
generator.BranchIfEqual(endOfCharCheck);
EmitHelpers.EmitThrow(generator, "TypeError", "Cannot convert string to char - the string must be exactly one character long");
generator.DefineLabelPosition(endOfCharCheck);
generator.LoadInt32(0);
generator.Call(ReflectionHelpers.String_GetChars);
break;
case TypeCode.DBNull:
throw new NotSupportedException("DBNull is not a supported parameter type.");
case TypeCode.Decimal:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.NewObject(ReflectionHelpers.Decimal_Constructor_Double);
break;
case TypeCode.Double:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.Empty:
throw new NotSupportedException("Empty is not a supported return type.");
case TypeCode.Int16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int32:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToInt64();
break;
case TypeCode.DateTime:
case TypeCode.Object:
// Check if the type must be unwrapped.
generator.Duplicate();
generator.IsInstance(typeof(Jurassic.Library.ClrInstanceWrapper));
var endOfUnwrapCheck = generator.CreateLabel();
generator.BranchIfFalse(endOfUnwrapCheck);
// Unwrap the wrapped instance.
generator.Call(ReflectionHelpers.ClrInstanceWrapper_GetWrappedInstance);
generator.DefineLabelPosition(endOfUnwrapCheck);
// Value types must be unboxed.
if (toType.IsValueType == true)
{
if (convertToAddress == true)
// Unbox.
generator.Unbox(toType);
else
// Unbox and copy to the stack.
generator.UnboxAny(toType);
//// Calling methods on value required the address of the value type, not the value type itself.
//if (argument.Source == BinderArgumentSource.ThisValue && argument.Type.IsValueType == true)
//{
// var temp = generator.CreateTemporaryVariable(argument.Type);
// generator.StoreVariable(temp);
// generator.LoadAddressOfVariable(temp);
// generator.ReleaseTemporaryVariable(temp);
//}
}
break;
case TypeCode.SByte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Single:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.String:
EmitConversion.ToString(generator, PrimitiveType.Any);
break;
case TypeCode.UInt16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt32:
EmitConversion.ToUInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToUnsignedInt64();
break;
}
// Label the end of the null check.
if (toType.IsValueType == false)
generator.DefineLabelPosition(endOfNullCheck);
}
/// <summary>
/// Generates a method that does type conversion and calls the bound method.
/// </summary>
/// <param name="generator"> The ILGenerator used to output the body of the method. </param>
/// <param name="argumentCount"> The number of arguments that will be passed to the delegate. </param>
/// <returns> A delegate that does type conversion and calls the method represented by this
/// object. </returns>
protected override void GenerateStub(ILGenerator generator, int argumentCount)
{
// Determine the methods that have the correct number of arguments.
var candidateMethods = new List <BinderMethod>();
foreach (var candidateMethod in this.targetMethods)
{
if (candidateMethod.IsArgumentCountCompatible(argumentCount) == true)
{
candidateMethods.Add(candidateMethod);
}
}
// Zero candidates means no overload had the correct number of arguments.
if (candidateMethods.Count == 0)
{
EmitHelpers.EmitThrow(generator, ErrorType.TypeError, string.Format("No overload for method '{0}' takes {1} arguments", this.Name, argumentCount));
EmitHelpers.EmitDefaultValue(generator, PrimitiveType.Any);
generator.Complete();
return;
}
// Select the method to call at run time.
generator.LoadInt32(candidateMethods.Count);
generator.NewArray(typeof(RuntimeMethodHandle));
for (int i = 0; i < candidateMethods.Count; i++)
{
generator.Duplicate();
generator.LoadInt32(i);
generator.LoadToken(candidateMethods[i]);
generator.StoreArrayElement(typeof(RuntimeMethodHandle));
}
generator.LoadArgument(0);
generator.LoadArgument(1);
generator.LoadArgument(2);
generator.Call(ReflectionHelpers.BinderUtilities_ResolveOverloads);
var endOfMethod = generator.CreateLabel();
for (int i = 0; i < candidateMethods.Count; i++)
{
// Check if this is the selected method.
ILLabel endOfIf = null;
if (i < candidateMethods.Count - 1)
{
generator.Duplicate();
generator.LoadInt32(i);
endOfIf = generator.CreateLabel();
generator.BranchIfNotEqual(endOfIf);
}
generator.Pop();
var targetMethod = candidateMethods[i];
// Convert the arguments.
foreach (var argument in targetMethod.GenerateArguments(generator, argumentCount))
{
// Load the input parameter value.
switch (argument.Source)
{
case BinderArgumentSource.ScriptEngine:
generator.LoadArgument(0);
break;
case BinderArgumentSource.ThisValue:
generator.LoadArgument(1);
break;
case BinderArgumentSource.InputParameter:
generator.LoadArgument(2);
generator.LoadInt32(argument.InputParameterIndex);
generator.LoadArrayElement(typeof(object));
break;
}
// Convert to the target type.
EmitConversionToType(generator, argument.Type, convertToAddress: argument.Source == BinderArgumentSource.ThisValue);
}
// Call the target method.
targetMethod.GenerateCall(generator);
// Convert the return value.
if (targetMethod.ReturnType == typeof(void))
{
EmitHelpers.EmitUndefined(generator);
}
else
{
EmitConversionToObject(generator, targetMethod.ReturnType);
}
// Branch to the end of the method if this was the selected method.
if (endOfIf != null)
{
generator.Branch(endOfMethod);
generator.DefineLabelPosition(endOfIf);
}
}
generator.DefineLabelPosition(endOfMethod);
generator.Complete();
}
/// <summary>
/// Pops the value on the stack, converts it from an object to the given type, then pushes
/// the result onto the stack.
/// </summary>
/// <param name="generator"> The IL generator. </param>
/// <param name="toType"> The type to convert to. </param>
/// <param name="convertToAddress"> <c>true</c> if the value is intended for use as an
/// instance pointer; <c>false</c> otherwise. </param>
internal static void EmitConversionToType(ILGenerator generator, Type toType, bool convertToAddress)
{
// Convert Null.Value to null if the target type is a reference type.
ILLabel endOfNullCheck = null;
if (toType.IsValueType == false)
{
var startOfElse = generator.CreateLabel();
endOfNullCheck = generator.CreateLabel();
generator.Duplicate();
EmitHelpers.EmitNull(generator);
generator.BranchIfNotEqual(startOfElse);
generator.Pop();
generator.LoadNull();
generator.Branch(endOfNullCheck);
generator.DefineLabelPosition(startOfElse);
}
switch (Type.GetTypeCode(toType))
{
case TypeCode.Boolean:
EmitConversion.ToBool(generator, PrimitiveType.Any);
break;
case TypeCode.Byte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Char:
EmitConversion.ToString(generator, PrimitiveType.Any);
generator.Duplicate();
generator.Call(ReflectionHelpers.String_Length);
generator.LoadInt32(1);
var endOfCharCheck = generator.CreateLabel();
generator.BranchIfEqual(endOfCharCheck);
EmitHelpers.EmitThrow(generator, ErrorType.TypeError, "Cannot convert string to char - the string must be exactly one character long");
generator.DefineLabelPosition(endOfCharCheck);
generator.LoadInt32(0);
generator.Call(ReflectionHelpers.String_GetChars);
break;
case TypeCode.DBNull:
throw new NotSupportedException("DBNull is not a supported parameter type.");
case TypeCode.Decimal:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.NewObject(ReflectionHelpers.Decimal_Constructor_Double);
break;
case TypeCode.Double:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.Empty:
throw new NotSupportedException("Empty is not a supported return type.");
case TypeCode.Int16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int32:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToInt64();
break;
case TypeCode.DateTime:
case TypeCode.Object:
// Check if the type must be unwrapped.
generator.Duplicate();
generator.IsInstance(typeof(Jurassic.Library.ClrInstanceWrapper));
var endOfUnwrapCheck = generator.CreateLabel();
generator.BranchIfFalse(endOfUnwrapCheck);
// Unwrap the wrapped instance.
generator.Call(ReflectionHelpers.ClrInstanceWrapper_GetWrappedInstance);
generator.DefineLabelPosition(endOfUnwrapCheck);
// Value types must be unboxed.
if (toType.IsValueType == true)
{
if (convertToAddress == true)
{
// Unbox.
generator.Unbox(toType);
}
else
{
// Unbox and copy to the stack.
generator.UnboxAny(toType);
}
//// Calling methods on value required the address of the value type, not the value type itself.
//if (argument.Source == BinderArgumentSource.ThisValue && argument.Type.IsValueType == true)
//{
// var temp = generator.CreateTemporaryVariable(argument.Type);
// generator.StoreVariable(temp);
// generator.LoadAddressOfVariable(temp);
// generator.ReleaseTemporaryVariable(temp);
//}
}
break;
case TypeCode.SByte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Single:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.String:
EmitConversion.ToString(generator, PrimitiveType.Any);
break;
case TypeCode.UInt16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt32:
EmitConversion.ToUInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToUnsignedInt64();
break;
}
// Label the end of the null check.
if (toType.IsValueType == false)
{
generator.DefineLabelPosition(endOfNullCheck);
}
}
/// <summary>
/// Generates IL for the script.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
protected override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Method signature: object FunctionDelegate(Compiler.Scope scope, object thisObject, Library.FunctionInstance functionObject, object[] arguments)
// Initialize the scope (note: the initial scope for a function is always declarative).
this.InitialScope.GenerateScopeCreation(generator, optimizationInfo);
// In ES3 the "this" value must be an object. See 10.4.3 in the spec.
if (this.StrictMode == false && this.MethodOptimizationHints.HasThis == true)
{
// if (thisObject == null || thisObject == Null.Value || thisObject == Undefined.Value)
EmitHelpers.LoadThis(generator);
generator.LoadNull();
generator.CompareEqual();
EmitHelpers.LoadThis(generator);
EmitHelpers.EmitNull(generator);
generator.CompareEqual();
generator.BitwiseOr();
EmitHelpers.LoadThis(generator);
EmitHelpers.EmitUndefined(generator);
generator.CompareEqual();
generator.BitwiseOr();
// {
var startOfFalse = generator.CreateLabel();
generator.BranchIfFalse(startOfFalse);
// thisObject = engine.Global;
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Global);
// } else {
var endOfIf = generator.CreateLabel();
generator.Branch(endOfIf);
generator.DefineLabelPosition(startOfFalse);
// thisObject = TypeConverter.ToObject(thisObject);
EmitHelpers.LoadThis(generator);
EmitConversion.ToObject(generator, PrimitiveType.Any, optimizationInfo);
// }
generator.DefineLabelPosition(endOfIf);
EmitHelpers.StoreThis(generator);
}
// Transfer the function name into the scope.
if (string.IsNullOrEmpty(this.Name) == false &&
(this.DeclarationType != FunctionDeclarationType.Getter && this.DeclarationType != FunctionDeclarationType.Setter) &&
this.Arguments.Any(a => a.Name == this.Name) == false &&
optimizationInfo.MethodOptimizationHints.HasVariable(this.Name))
{
EmitHelpers.LoadFunction(generator);
var functionName = new NameExpression(this.InitialScope, this.Name);
functionName.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
// Transfer the arguments object into the scope.
if (this.MethodOptimizationHints.HasArguments == true && this.Arguments.Any(a => a.Name == "arguments") == false)
{
// prototype
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.FunctionInstance_InstancePrototype);
// callee
EmitHelpers.LoadFunction(generator);
generator.CastClass(typeof(Library.UserDefinedFunction));
// scope
EmitHelpers.LoadScope(generator);
generator.CastClass(typeof(DeclarativeScope));
// argumentValues
EmitHelpers.LoadArgumentsArray(generator);
generator.NewObject(ReflectionHelpers.Arguments_Constructor);
var arguments = new NameExpression(this.InitialScope, "arguments");
arguments.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
// Transfer the argument values into the scope.
// Note: the arguments array can be smaller than expected.
if (this.Arguments.Count > 0)
{
for (int i = 0; i < this.Arguments.Count; i++)
{
// Check if a duplicate argument name exists.
bool duplicate = false;
for (int j = i + 1; j < this.Arguments.Count; j++)
{
if (this.Arguments[i].Name == this.Arguments[j].Name)
{
duplicate = true;
break;
}
}
if (duplicate == true)
{
continue;
}
var loadDefaultValue = generator.CreateLabel();
var storeValue = generator.CreateLabel();
// Check if an array element exists.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadArrayLength();
generator.LoadInt32(i);
generator.BranchIfLessThanOrEqual(loadDefaultValue);
// Load the parameter value from the parameters array.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadInt32(i);
generator.LoadArrayElement(typeof(object));
if (this.Arguments[i].DefaultValue == null)
{
// Branch to the part where it stores the value.
generator.Branch(storeValue);
// Load undefined.
generator.DefineLabelPosition(loadDefaultValue);
EmitHelpers.EmitUndefined(generator);
}
else
{
// Check if it's undefined.
generator.Duplicate();
EmitHelpers.EmitUndefined(generator);
generator.BranchIfNotEqual(storeValue);
generator.Pop();
// Load the default value.
generator.DefineLabelPosition(loadDefaultValue);
this.Arguments[i].DefaultValue.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Arguments[i].DefaultValue.ResultType);
}
// Store the value in the scope.
generator.DefineLabelPosition(storeValue);
var argument = new NameExpression(this.InitialScope, this.Arguments[i].Name);
argument.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
}
// Initialize any declarations.
this.InitialScope.GenerateDeclarations(generator, optimizationInfo);
// Generate code for the body of the function.
this.AbstractSyntaxTree.GenerateCode(generator, optimizationInfo);
// Define the return target - this is where the return statement jumps to.
// ReturnTarget can be null if there were no return statements.
if (optimizationInfo.ReturnTarget != null)
{
generator.DefineLabelPosition(optimizationInfo.ReturnTarget);
}
// Load the return value. If the variable is null, there were no return statements.
if (optimizationInfo.ReturnVariable != null)
{
// Return the value stored in the variable. Will be null if execution hits the end
// of the function without encountering any return statements.
generator.LoadVariable(optimizationInfo.ReturnVariable);
}
else
{
// There were no return statements - return null.
generator.LoadNull();
}
}
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
generator.LoadInt32((int)this.Value);
else if (this.Value is double)
generator.LoadDouble((double)this.Value);
else if (this.Value is string)
generator.LoadString((string)this.Value);
else if (this.Value is bool)
generator.LoadBoolean((bool)this.Value);
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List<Expression>)
{
// Construct an array literal.
var arrayLiteral = (List<Expression>)this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i ++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
generator.LoadNull();
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New);
}
else if (this.Value is List<KeyValuePair<Expression, Expression>>)
{
// This is an object literal.
var properties = (List<KeyValuePair<Expression, Expression>>)this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
foreach (var keyValuePair in properties)
{
Expression propertyName = keyValuePair.Key;
Expression propertyValue = keyValuePair.Value;
generator.Duplicate();
// The key can be a property name or an expression that evaluates to a name.
propertyName.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, propertyName.ResultType);
var functionValue = propertyValue as FunctionExpression;
if (functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Getter)
{
// Add a getter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
functionValue.GenerateDisplayName(generator, optimizationInfo, "get " + (string)((LiteralExpression)propertyName).Value, true);
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralGetter);
}
else if(functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Setter)
{
// Add a setter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
functionValue.GenerateDisplayName(generator, optimizationInfo, "set " + (string)((LiteralExpression)propertyName).Value, true);
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralSetter);
}
else
{
// Add a new property to the object.
propertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyValue is FunctionExpression && propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
((FunctionExpression)propertyValue).GenerateDisplayName(generator, optimizationInfo, (string)((LiteralExpression)propertyName).Value, false);
EmitConversion.ToAny(generator, propertyValue.ResultType);
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralValue);
}
}
}
else
throw new NotImplementedException("Unknown literal type.");
}
