private Expression Convert(LinqExp.MethodCallExpression linqCall)
{
return(Expression.Call(
ConvertExp(linqCall.Object),
linqCall.Method,
Convert(linqCall.Arguments)));
}
private MemberBinding Convert(LinqExp.MemberBinding linqBinding)
{
switch (linqBinding.BindingType)
{
case LinqExp.MemberBindingType.Assignment:
var linqMemberAssignment = (LinqExp.MemberAssignment)linqBinding;
return(Expression.Bind(
linqMemberAssignment.Member,
ConvertExp(linqMemberAssignment.Expression)));
case LinqExp.MemberBindingType.MemberBinding:
var linqMemberBinding = (LinqExp.MemberMemberBinding)linqBinding;
return(Expression.MemberBind(
linqMemberBinding.Member,
linqMemberBinding.Bindings.Project(Convert)));
case LinqExp.MemberBindingType.ListBinding:
var linqListBinding = (LinqExp.MemberListBinding)linqBinding;
return(Expression.ListBind(
linqListBinding.Member,
linqListBinding.Initializers.Project(Convert)));
default:
throw new ArgumentOutOfRangeException();
}
}
private Expression ConvertLambda(LinqExp.LambdaExpression linqLambda)
{
return(Expression.Lambda(
linqLambda.Type,
ConvertExp(linqLambda.Body),
linqLambda.Parameters.Project(Convert)));
}
private Expression Convert(LinqExp.ConditionalExpression linqConditional)
{
return(Expression.Condition(
ConvertExp(linqConditional.Test),
ConvertExp(linqConditional.IfTrue),
ConvertExp(linqConditional.IfFalse)));
}
public static MethodCallExpression Call(Expression instance, MethodInfo method, params Expression[] arguments)
{
Contract.RequiresNotNull(method, "method");
Contract.Requires(!method.IsGenericMethodDefinition, "method");
Contract.Requires(!method.ContainsGenericParameters, "method");
if (method.IsStatic) {
Contract.Requires(instance == null, "instance", "Instance must be null for static method");
} else {
Contract.RequiresNotNull(instance, "instance");
if (!TypeUtils.CanAssign(method.DeclaringType, instance.Type)) {
throw new ArgumentException(
String.Format(
"Invalid instance type for {0}.{1}. Expected {0}, got {2}.",
method.DeclaringType.Name,
method.Name,
instance.Type.Name
),
"instance"
);
}
}
Contract.RequiresNotNullItems(arguments, "arguments");
ParameterInfo[] parameters = method.GetParameters();
ValidateCallArguments(parameters, arguments);
return new MethodCallExpression(method, instance, CollectionUtils.ToReadOnlyCollection(arguments), parameters);
}
internal MethodCallExpression(MethodInfo /*!*/ method, Expression instance, ReadOnlyCollection<Expression> /*!*/ arguments, ParameterInfo[] /*!*/ parameters)
: base(AstNodeType.Call) {
_method = method;
_instance = instance;
_arguments = new List<Expression>(arguments);
_parameterInfos = parameters;
}
public static UnaryExpression Not(Expression expression)
{
Contract.RequiresNotNull(expression, "expression");
Contract.Requires(TypeUtils.IsIntegerOrBool(expression.Type), "expression", "Expression type must be integer or boolean.");
return new UnaryExpression(AstNodeType.Not, expression, expression.Type);
}
internal override Expression UpdateFromReturn(MethodBinderContext context, Expression[] parameters) {
return Ast.Call(
typeof(BinderOps).GetMethod("UpdateBox").MakeGenericMethod(_elementType),
Ast.Convert(parameters[Index], BoxType),
Ast.Read(_tmp)
);
}
public static ThrowStatement Throw(SourceSpan span, Expression value)
{
if (value != null) {
Contract.Requires(TypeUtils.CanAssign(typeof(Exception), value.Type));
}
return new ThrowStatement(span, value);
}
public static Expression Apply(Expression[] args)
{
if (args.Length == 0)
{
return null;
}
Expression c = Ast.ConvertHelper(args[0], typeof(Callable));
if (args.Length > 1)
{
Expression arg = Ast.ConvertHelper(args[args.Length - 1], typeof(object));
if (arg.IsConstant(null)) Debugger.Break();
for (int i = args.Length - 2; i > 0; i--)
{
arg = MakeCons(args[i], arg);
}
return Ast.ComplexCallHelper(c, ICallable_Call, Ast.Call(ListToVector, arg));
}
else
{
return null;
}
}
public static ScopeStatement Scope(SourceSpan span, Expression scope, Statement body) {
Contract.RequiresNotNull(scope, "scope");
Contract.RequiresNotNull(body, "body");
Contract.Requires(TypeUtils.CanAssign(typeof(IAttributesCollection), scope.Type), "scope", "Scope must be IAttributesCollection");
return new ScopeStatement(span, scope, body);
}
public static SwitchStatement Switch(SourceSpan span, SourceLocation header, Expression value, params SwitchCase[] cases)
{
Contract.RequiresNotNull(value, "value");
Contract.Requires(value.Type == typeof(int), "value", "Value must be int");
Contract.RequiresNotEmpty(cases, "cases");
Contract.RequiresNotNullItems(cases, "cases");
bool @default = false;
int max = Int32.MinValue;
int min = Int32.MaxValue;
foreach (SwitchCase sc in cases) {
if (sc.IsDefault) {
Contract.Requires(@default == false, "cases", "Only one default clause allowed");
@default = true;
} else {
int val = sc.Value;
if (val > max) max = val;
if (val < min) min = val;
}
}
Contract.Requires(UniqueCaseValues(cases, min, max), "cases", "Case values must be unique");
return new SwitchStatement(span, header, value, CollectionUtils.ToReadOnlyCollection(cases));
}
public DoStatement While(Expression condition)
{
Contract.RequiresNotNull(condition, "condition");
Contract.Requires(condition.Type == typeof(bool), "condition", "Condition must be boolean");
return new DoStatement(_statementSpan, _doLocation, condition, _body);
}
/// <summary>
/// Called by <see cref="DoStatementBuilder"/>.
/// </summary>
internal DoStatement(SourceSpan span, SourceLocation header, Expression /*!*/ test, Statement /*!*/ body)
: base(AstNodeType.DoStatement, span)
{
_header = header;
_test = test;
_body = body;
}
public static NewArrayExpression NewArrayHelper(Type type, IList<Expression> initializers)
{
Contract.RequiresNotNullItems(initializers, "initializers");
Contract.RequiresNotNull(type, "type");
Contract.Requires(type.IsArray, "type", "Not an array type");
Type element = type.GetElementType();
Expression[] clone = null;
for (int i = 0; i < initializers.Count; i++) {
Expression initializer = initializers[i];
if (!TypeUtils.CanAssign(element, initializer.Type)) {
if (clone == null) {
clone = new Expression[initializers.Count];
for (int j = 0; j < i; j++) {
clone[j] = initializers[j];
}
}
initializer = Ast.Convert(initializer, element);
}
if (clone != null) {
clone[i] = initializer;
}
}
return NewArray(type, clone ?? initializers);
}
/// <summary>
/// Performs an assignment variable = value
/// </summary>
public static BoundAssignment Assign(Variable variable, Expression value)
{
Contract.RequiresNotNull(variable, "variable");
Contract.RequiresNotNull(value, "value");
Contract.Requires(TypeUtils.CanAssign(variable.Type, value.Type));
return new BoundAssignment(variable, value);
}
public override Expression asCLRSetValueExpression(Expression newValue)
{
// Context.markAsUncompilable();
// return Expression.Constant(newValue);
throw new InvalidOperationException("A NonStackResidentVariableDeclaration cannot be used to generate code. Use either an InstanceVariableDeclaration or a NamespaceResidentVariableDeclaration instead.");
}
private Expression[] GetParameters(Expression[] parameters) {
Expression[] res = new Expression[_nameIndexes.Length];
for (int i = 0; i < _nameIndexes.Length; i++) {
res[i] = parameters[_nameIndexes[i] + _argIndex];
}
return res;
}
public static Expression Eqv(Expression[] obj)
{
if (obj.Length == 2)
{
var o1 = Unwrap(obj[0]);
var o2 = Unwrap(obj[1]);
Func<Type, bool> p = t => o1.Type == t || o2.Type == t;
bool vt = !(o1.Type.IsValueType || o2.Type.IsValueType);
if (p(typeof(SymbolId))
|| p(typeof(bool))
|| (vt && !p(typeof(object)) && !p(typeof(Fraction)) && !p(typeof(IntX)) && !p(typeof(ComplexFraction)))
)
{
return Ast.Equal(obj[0], obj[1]);
}
else if (p(typeof(double)))
{
return null;
}
else if (o1 is ConstantExpression || o2 is ConstantExpression)
{
return Ast.Call(typeof(object).GetMethod("Equals", BindingFlags.Public | BindingFlags.Static), obj);
}
}
return null;
}
private IEnumerable <Expression> Convert(IEnumerable <LinqExp.Expression> linqExpressions)
{
return(linqExpressions.Project(arg =>
(arg.NodeType == LinqExp.ExpressionType.Quote)
? Expression.Constant(((LinqExp.UnaryExpression)arg).Operand, arg.Type)
: ConvertExp(arg)));
}
internal ConditionalExpression(Expression/*!*/ test, Expression/*!*/ ifTrue, Expression/*!*/ ifFalse, Type/*!*/ type)
: base(AstNodeType.Conditional) {
_test = test;
_true = ifTrue;
_false = ifFalse;
_expressionType = type;
}
private Expression[] ConstantNames() {
Expression[] res = new Expression[_names.Length];
for (int i = 0; i < _names.Length; i++) {
res[i] = Ast.Constant(_names[i]);
}
return res;
}
/// <summary>
/// Creates a new ErrorInfo which represents an exception that should
/// be thrown.
/// </summary>
public static ErrorInfo FromException(Expression exceptionValue)
{
Contract.RequiresNotNull(exceptionValue, "exceptionValue");
Contract.Requires(typeof(Exception).IsAssignableFrom(exceptionValue.Type), "exceptionValue", "must by an Exception instance");
return new ErrorInfo(exceptionValue, null);
}
public static UnaryExpression Negate(Expression expression)
{
Contract.RequiresNotNull(expression, "expression");
Contract.Requires(TypeUtils.IsArithmetic(expression.Type) && !TypeUtils.IsUnsigned(expression.Type), "expression", "Expression must be signed numeric type");
return new UnaryExpression(AstNodeType.Negate, expression, expression.Type);
}
internal override MemberTracker BindToInstance(Expression instance) {
if (IsStatic) {
return this;
}
return new BoundMemberTracker(this, instance);
}
static Expression MakeCallBack(Variable proc, Expression[] a)
{
var procr = Ast.ConvertHelper(Ast.Read(proc), typeof(Callable));
MethodInfo call = GetCallable(a.Length);
var expr = Ast.Call(procr, call, a);
return expr;
}
internal ArrayIndexAssignment(Expression /*!*/ array, Expression /*!*/ index, Expression /*!*/ value)
: base(AstNodeType.ArrayIndexAssignment) {
_array = array;
_index = index;
_value = value;
_elementType = array.Type.GetElementType();
}
public static VariableReference[] Bind(Expression test, Statement target) {
Assert.NotNull(test, target);
RuleBinder rb = new RuleBinder();
rb.WalkNode(test);
rb.WalkNode(target);
return rb.GetReferences();
}
public static IfStatementTest IfCondition(SourceSpan span, SourceLocation header, Expression test, Statement body)
{
Contract.RequiresNotNull(test, "test");
Contract.RequiresNotNull(body, "body");
Contract.Requires(test.Type == typeof(bool), "test", "Test must be boolean");
return new IfStatementTest(span, header, test, body);
}
public static Expression IsNull(Expression[] values)
{
if (values.Length != 1)
{
return null;
}
return Ast.Equal(values[0], Ast.Null());
}
internal SwitchStatement(SourceSpan span, SourceLocation header, Expression/*!*/ testValue, ReadOnlyCollection<SwitchCase>/*!*/ cases)
: base(AstNodeType.SwitchStatement, span) {
Assert.NotNullItems(cases);
_testValue = testValue;
_cases = cases;
_header = header;
}
public static Expression IsPair(Expression[] values)
{
if (values.Length != 1)
{
return null;
}
return Ast.TypeIs(values[0], typeof(Cons));
}
public static Expression Cons(Expression[] values)
{
if (values.Length == 2)
{
return Ast.New(cons, values[0], values[1]);
}
return null;
}
/// <summary>
/// Null test means infinite loop.
/// </summary>
internal LoopStatement(SourceSpan span, SourceLocation header, Expression test, Expression increment, Statement /*!*/ body, Statement @else)
: base(AstNodeType.LoopStatement, span) {
_test = test;
_increment = increment;
_body = body;
_else = @else;
_header = header;
}
public static Expression Eq(Expression[] obj)
{
if (obj.Length == 2)
{
return Ast.Equal(obj[0], obj[1]);
}
return null;
}
internal override Expression ToExpression(MethodBinderContext context, IList<ArgBuilder> args, IList<Expression> parameters, Expression ret)
{
List<Expression> sets = new List<Expression>();
Variable tmp = null;// context.GetTemporary(ret.Type, "val");
for (int i = 0; i < _indexesUsed.Length; i++) {
Expression value = parameters[parameters.Count - _kwArgCount + _indexesUsed[i]];
switch(_membersSet[i].MemberType) {
case MemberTypes.Field:
FieldInfo fi = (FieldInfo)_membersSet[i];
if (!fi.IsLiteral && !fi.IsInitOnly) {
sets.Add(Ast.AssignField(Ast.Read(tmp), fi, Ast.ConvertHelper(value, fi.FieldType)));
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(RuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(true),
Ast.Constant(fi.Name)
),
fi.FieldType
)
);
}
break;
case MemberTypes.Property:
PropertyInfo pi = (PropertyInfo)_membersSet[i];
if (pi.GetSetMethod(ScriptDomainManager.Options.PrivateBinding) != null) {
sets.Add(Ast.AssignProperty(Ast.Read(tmp), pi, Ast.ConvertHelper(value, pi.PropertyType)));
} else {
// call a helper which throws the error but "returns object"
sets.Add(
Ast.Convert(
Ast.Call(
typeof(RuntimeHelpers).GetMethod("ReadOnlyAssignError"),
Ast.Constant(false),
Ast.Constant(pi.Name)
),
pi.PropertyType
)
);
}
break;
}
}
Expression newCall = Ast.Comma(
0,
ArrayUtils.Insert<Expression>(
Ast.Assign(tmp, ret),
sets.ToArray()
)
);
return _builder.ToExpression(context, args, parameters, newCall);
}
public InstanceVariableDeclaration(NameBindingScope scope, ESSymbol name) : base(scope, name)
{
var namedSlotsObject = Expression.Convert(Scope.SelfParameter, TypeGuru.esNamedSlotsObjectType);
namedSlots = Expression.Field(namedSlotsObject, "namedSlots");
var statusFlags = Expression.Field(namedSlotsObject, "statusFlags");
isMutable = Expression.Equal(Expression.And(statusFlags, mutabilityFlagBitConstant), zeroConstant);
}
private ParameterExpression Convert(LinqExp.ParameterExpression linqParam)
{
if (_parameters.TryGetValue(linqParam, out var param))
{
return(param);
}
return(_parameters[linqParam] = Expression.Parameter(linqParam.Type, linqParam.Name));
}
public override Expression asCLRSetValueExpression(Expression newValue)
{
return(Expression.Condition(
isMutable,
Expression.Assign(Expression.ArrayAccess(namedSlots, slotIndex), newValue),
Expression.Block(
TypeGuru.objectType,
Expression.Throw(Expression.Constant(new ImmutableObjectException())),
newValue)));
}
public static Expression[] expressionArrayFor(DynamicMetaObject[] metaObjects)
{
var expressionArray = new Expression[metaObjects.Length];
int i = 0;
foreach (var metaObject in metaObjects)
{
expressionArray[i++] = metaObject.Expression.withCanonicalArgumentType();
}
return(expressionArray);
}
private NewExpression Convert(LinqExp.NewExpression linqNew)
{
return((linqNew.Members != null)
? Expression.New(
linqNew.Constructor,
Convert(linqNew.Arguments),
linqNew.Members)
: Expression.New(
linqNew.Constructor,
Convert(linqNew.Arguments)));
}
public virtual bool compile(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out Expression <FuncNs.Func <Object> > lambda)
{
Expression rootExpression;
if (compile(rootParseNodeType, environment, selfValue, rootParameters, out rootExpression))
{
lambda = Expression.Lambda <FuncNs.Func <Object> >(rootExpression, false, new ParameterExpression[0]);
return(true);
}
lambda = null;
return(false);
}
public List <ParameterExpression> parametersFor(Object[] arguments)
{
if (arguments == null || arguments.Length < 1)
{
return(null);
}
List <ParameterExpression> rootParameters = new List <ParameterExpression>();
for (var i = 0; i < arguments.Length; i++)
{
rootParameters.Add(Expression.Parameter(TypeGuru.objectType, "_a" + (i + 1)));
}
return(rootParameters);
}
public override Expression Bind(Object[] args, ReadOnlyCollection <ParameterExpression> parameters, LabelTarget returnLabel)
{
Expression testRuleValidityExpression = null;
Expression getVariableValueExpression = null;
doAllButFinalBinding(
args,
(BindingHandle handle) => {
testRuleValidityExpression = Expression.Constant(true);
var handleConstant = Expression.Constant(handle);
getVariableValueExpression = handle.IsDirect ?
Expression.Field(handleConstant, TypeGuru.directBindingHandleType, "value") :
Expression.Property(handleConstant, "Value");
});
return(Expression
.IfThen(
testRuleValidityExpression,
Expression.Return(returnLabel, getVariableValueExpression)));
}
public override Expression Bind(Object[] args, ReadOnlyCollection <ParameterExpression> parameters, LabelTarget returnLabel)
{
Expression testRuleValidityExpression = null;
Expression setVariableValueExpression = null;
ParameterExpression value = parameters[1];
doAllButFinalBinding(
args,
(BindingHandle handle) => {
testRuleValidityExpression = Expression.Constant(true);
setVariableValueExpression =
Expression.Assign(
Expression.Property(Expression.Constant(handle), "Value"),
value);
});
return(Expression
.IfThen(
testRuleValidityExpression,
Expression.Return(returnLabel, setVariableValueExpression)));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
var method = (ESMethod)Value;
Expression invokeExpression = null;
var numArgs = args.Length;
if (numArgs - method.NumArgs != 1)
{
var esClass = ValueClass;
var kernel = esClass.ObjectSpace;
return(metaObjectToThrowInvalidFunctionCallException(
kernel.selectorToEvaluatMethodWithNumArgs(Math.Max(0, numArgs - 1)),
args,
"Argument count mismatch",
ESCompiledCode.methodFunctionTypeForNumArgs(method.NumArgs),
ESCompiledCode.blockFunctionTypeForNumArgs(args.Length)));
}
invokeExpression = ExpressionTreeGuru.expressionToInvokeESMethod(this.asExpressionWithFormalType(), expressionArrayFor(args));
return(new DynamicMetaObject(invokeExpression, DefaultBindingRestrictions, method));
}
public override DynamicMetaObject BindInvoke(InvokeBinder binder, DynamicMetaObject[] args)
{
var block = (ESBlock)Value;
Expression invokeExpression = null;
var numArgs = args.Length;
if (numArgs != block.NumArgs)
{
var esClass = ValueClass;
var objectSpace = esClass.ObjectSpace;
return(metaObjectToThrowInvalidFunctionCallException(
objectSpace.selectorToEvaluatBlockWithNumArgs(numArgs),
args,
"Argument count mismatch",
ESCompiledCode.blockFunctionTypeForNumArgs(block.NumArgs),
ESCompiledCode.blockFunctionTypeForNumArgs(args.Length)));
}
invokeExpression = ExpressionTreeGuru.expressionToInvokeESBlock(this.asExpressionWithFormalType(), expressionArrayFor(args));
return(new DynamicMetaObject(invokeExpression, DefaultBindingRestrictions, block));
}
public override Expression asCLRSetValueExpression(Expression newValue)
{
return(Expression.Invoke(Expression.Field(setVariableCallSite, CodeGenerationContext.callSiteType[1], "Target"), setVariableCallSite, Scope.SelfParameter, newValue));
}
public abstract Expression asCLRSetValueExpression(Expression newValue);
public ESBehaviorDynamicMetaObject(Expression expression, BindingRestrictions restrictions, object value, ESBehavior valueClass) : base(expression, restrictions, value, valueClass)
{
}
public override DynamicMetaObject BindUnaryOperation(UnaryOperationBinder binder)
{
DynamicMetaObject messageSendMO;
Expression value;
DynamicMetaObject arg;
switch (binder.Operation)
{
case ExpressionType.Negate:
if (createMetaObjectToSendMessage("negated", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.UnaryPlus:
if (createMetaObjectToSendMessage("abs", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Not:
if (createMetaObjectToSendMessage("not", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Decrement:
if (createMetaObjectToSendMessage("decrement", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.Increment:
if (createMetaObjectToSendMessage("increment", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.OnesComplement:
if (createMetaObjectToSendMessage("bitInvert", DynamicBindingGuru.emptyArgArray, out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.IsTrue:
value = Expression.Constant(true);
arg = value.asDynamicMetaObject(BindingRestrictions.Empty, true);
if (createMetaObjectToSendMessage("=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
case ExpressionType.IsFalse:
value = Expression.Constant(false);
arg = value.asDynamicMetaObject(BindingRestrictions.Empty, false);
if (createMetaObjectToSendMessage("=", argArrayFor(arg), out messageSendMO))
{
return(messageSendMO);
}
break;
default:
case ExpressionType.Extension:
messageSendMO = null;
break;
}
if (messageSendMO == null)
{
var esClass = ValueClass;
var kernel = esClass.ObjectSpace;
var selector = kernel.symbolFor("??");
messageSendMO = metaObjectToSendDoesNotUnderstand(selector, DynamicBindingGuru.emptyArgArray);
}
return(binder.FallbackUnaryOperation(this, messageSendMO));
}
public override DynamicMetaObject BindDeleteMember(DeleteMemberBinder binder)
{
DynamicMetaObject messageSendMO;
var kernel = ValueClass.ObjectSpace;
var memberName = kernel.symbolFor(binder.Name);
if (createMetaObjectToSendMessage("removeKey:", DynamicBindingGuru.argArrayFor(Expression.Constant(memberName).asDynamicMetaObject(BindingRestrictions.Empty, memberName)), out messageSendMO))
{
return(messageSendMO);
}
return(binder.FallbackDeleteMember(this, messageSendMO));
}
public ESDynamicMetaObject(Expression expression, BindingRestrictions restrictions, Object value, ESBehavior valueClass) : base(expression, restrictions, value)
{
this.valueClass = valueClass;
}
public static ParameterExpression parameterExpressionFrom(ESSymbol name, Type parameterType)
{
return(Expression.Parameter(parameterType, name.PrimitiveValue));
}
public override Expression asCLRSetValueExpression(Expression newValue)
{
return(Expression.Throw(Expression.Constant("Method and block parameters are not assignable (" + NameString + ")"), typeof(ImmutableBindingException)));
}
public override Expression asCLRSetValueExpression(Expression newValue)
{
return(Expression.Assign(parameter, newValue));
}
public override Expression asCLRGetValueExpression()
{
return(Expression.ArrayAccess(namedSlots, slotIndex));
}
public override Expression asCLRGetValueExpression()
{
return(Expression.Invoke(Expression.Field(getVariableCallSite, CodeGenerationContext.callSiteType[0], "Target"), getVariableCallSite, Scope.SelfParameter));
}
public Expression asCLRSetValueExpression(Expression newValue)
{
return(declaration.asCLRSetValueExpression(newValue));
}
public virtual bool compile(ScriptType rootParseNodeType, NamespaceObject environment, Object selfValue, List <ParameterExpression> rootParameters, out Expression expression)
{
BlockLiteralNode blockLiteralNode;
if (compile(rootParseNodeType, selfValue, rootParameters, out blockLiteralNode))
{
expression = blockLiteralNode.asCLRExpression(environment, null);
var undeclaredVariables = blockLiteralNode.UndeclaredVariables;
if (undeclaredVariables != null && undeclaredVariables.Count > 0)
{
handleUndeclaredVariableReferences(undeclaredVariables, SourceSpan.None);
}
return(ErrorCount < 1);
}
expression = null;
return(false);
}