internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, PythonOperationKind op) {
MSAst.Expression assignment;
if (op != PythonOperationKind.None) {
right = ag.Operation(
typeof(object),
op,
Transform(ag, typeof(object)),
right
);
}
if (_reference.PythonVariable != null) {
assignment = ag.Globals.Assign(
ag.Globals.GetVariable(_reference.PythonVariable),
AstGenerator.ConvertIfNeeded(right, typeof(object))
);
} else {
assignment = Ast.Call(
null,
typeof(ScriptingRuntimeHelpers).GetMethod("SetName"),
new [] {
ag.LocalContext,
ag.Globals.GetSymbol(_name),
AstUtils.Convert(right, typeof(object))
}
);
}
SourceSpan aspan = span.IsValid ? new SourceSpan(Span.Start, span.End) : SourceSpan.None;
return ag.AddDebugInfoAndVoid(assignment, aspan);
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return ag.Get(
type,
_name,
ag.Transform(_target)
);
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return Ast.Call(
AstGenerator.GetHelperMethod("Repr"), // method
ag.LocalContext,
ag.TransformAsObject(_expression) // args
);
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
MSAst.Expression left = ag.Transform(_left);
MSAst.Expression right = ag.Transform(_right);
Type t = left.Type == right.Type ? left.Type : typeof(object);
MSAst.ParameterExpression tmp = ag.GetTemporary("__all__", t);
return Ast.Condition(
Binders.Convert(
ag.BinderState,
typeof(bool),
ConversionResultKind.ExplicitCast,
AstUtils.Assign(
tmp,
AstUtils.Convert(
left,
t
)
)
),
AstUtils.Convert(
right,
t
),
tmp
);
}
internal AstGenerator(AstGenerator/*!*/ parent, string name, bool generator, bool print)
: this(name, generator, false) {
Assert.NotNull(parent);
_context = parent.Context;
_binderState = parent.BinderState;
_document = _context.SourceUnit.Document;
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
MSAst.ParameterExpression list = ag.GetTemporary("list_comprehension_list", typeof(List));
// 1. Initialization code - create list and store it in the temp variable
MSAst.Expression initialize =
Ast.Assign(
list,
Ast.Call(
AstGenerator.GetHelperMethod("MakeList", Type.EmptyTypes) // method
)
);
// 2. Create body from _item: list.Append(_item)
MSAst.Expression body = ag.AddDebugInfo(
Ast.Call(
AstGenerator.GetHelperMethod("ListAddForComprehension"),
list,
ag.TransformAsObject(_item)
),
_item.Span
);
// 3. Transform all iterators in reverse order, building the true body:
int current = _iterators.Length;
while (current-- > 0) {
ListComprehensionIterator iterator = _iterators[current];
body = iterator.Transform(ag, body);
}
return Ast.Block(
initialize,
body,
list // result
);
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return ag.Get(
type,
SymbolTable.IdToString(_name),
ag.Transform(_target)
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
List<MSAst.Expression> statements = new List<MSAst.Expression>();
for (int i = 0; i < _names.Length; i++) {
statements.Add(
// _references[i] = PythonOps.Import(<code context>, _names[i])
ag.AddDebugInfo(
AstUtils.Assign(
_variables[i].Variable,
Ast.Call(
AstGenerator.GetHelperMethod( // helper
_asNames[i] == SymbolId.Empty ? "ImportTop" : "ImportBottom"
),
AstUtils.CodeContext(), // 1st arg - code context
Ast.Constant(_names[i].MakeString()), // 2nd arg - module name
Ast.Constant(_forceAbsolute ? 0 : -1) // 3rd arg - absolute or relative imports
)
),
_names[i].Span
)
);
}
statements.Add(Ast.Empty());
return ag.AddDebugInfo(Ast.Block(statements.ToArray()), Span);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
MSAst.Expression raiseExpression;
if (_type == null && _value == null && _traceback == null) {
raiseExpression = Ast.Call(
AstGenerator.GetHelperMethod("MakeRethrownException"),
ag.LocalContext
);
if (!ag._isEmittingFinally) {
raiseExpression = Ast.Block(
ag.UpdateLineUpdated(true),
raiseExpression
);
}
} else {
raiseExpression = Ast.Call(
AstGenerator.GetHelperMethod("MakeException"),
ag.LocalContext,
ag.TransformOrConstantNull(_type, typeof(object)),
ag.TransformOrConstantNull(_value, typeof(object)),
ag.TransformOrConstantNull(_traceback, typeof(object))
);
}
return ag.AddDebugInfo(
Ast.Throw(raiseExpression),
Span
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
MSAst.MethodCallExpression call;
if (_locals == null && _globals == null) {
// exec code
call = Ast.Call(
AstGenerator.GetHelperMethod("UnqualifiedExec"),
AstUtils.CodeContext(),
ag.TransformAsObject(_code)
);
} else {
// exec code in globals [ , locals ]
// We must have globals now (locals is last and may be absent)
Debug.Assert(_globals != null);
call = Ast.Call(
AstGenerator.GetHelperMethod("QualifiedExec"),
AstUtils.CodeContext(),
ag.TransformAsObject(_code),
ag.TransformAndDynamicConvert(_globals, typeof(IAttributesCollection)),
ag.TransformOrConstantNull(_locals, typeof(object))
);
}
return ag.AddDebugInfo(call, Span);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
MSAst.Expression result;
if (_else != null) {
result = ag.Transform(_else);
} else {
result = AstUtils.Empty();
}
// Now build from the inside out
int i = _tests.Length;
while (i-- > 0) {
IfStatementTest ist = _tests[i];
result = ag.AddDebugInfoAndVoid(
Ast.Condition(
ag.TransformAndDynamicConvert(ist.Test, typeof(bool)),
ag.TransformMaybeSingleLineSuite(ist.Body, ist.Test.Start),
result
),
new SourceSpan(ist.Start, ist.Header)
);
}
return result;
}
internal override MSAst.Expression Transform(AstGenerator ag) {
if (ag.InLoop) {
return ag.AddDebugInfo(MSAst.Expression.Break(ag.BreakLabel), Span);
} else {
return null;
}
}
internal override MSAst.Expression Transform(AstGenerator ag) {
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>();
for (int i = 0; i < _names.Length; i++) {
statements.Add(
// _references[i] = PythonOps.Import(<code context>, _names[i])
ag.AddDebugInfoAndVoid(
GlobalAllocator.Assign(
ag.Globals.GetVariable(ag, _variables[i]),
Ast.Call(
AstGenerator.GetHelperMethod( // helper
_asNames[i] == null ? "ImportTop" : "ImportBottom"
),
ag.LocalContext, // 1st arg - code context
AstUtils.Constant(_names[i].MakeString()), // 2nd arg - module name
AstUtils.Constant(_forceAbsolute ? 0 : -1) // 3rd arg - absolute or relative imports
)
),
_names[i].Span
)
);
}
statements.Add(AstUtils.Empty());
return ag.AddDebugInfo(Ast.Block(statements.ToReadOnlyCollection()), Span);
}
private MSAst.Expression[] GetActionArgumentsForGetOrDelete(AstGenerator ag) {
TupleExpression te = _index as TupleExpression;
if (te != null && te.IsExpandable) {
return ArrayUtils.Insert(AstUtils.CodeContext(), ag.Transform(_target), ag.Transform(te.Items));
}
SliceExpression se = _index as SliceExpression;
if (se != null) {
if (se.StepProvided) {
return new MSAst.Expression[] {
AstUtils.CodeContext(),
ag.Transform(_target),
GetSliceValue(ag, se.SliceStart),
GetSliceValue(ag, se.SliceStop),
GetSliceValue(ag, se.SliceStep)
};
}
return new MSAst.Expression[] {
AstUtils.CodeContext(),
ag.Transform(_target),
GetSliceValue(ag, se.SliceStart),
GetSliceValue(ag, se.SliceStop)
};
}
return new MSAst.Expression[] { AstUtils.CodeContext(), ag.Transform(_target), ag.Transform(_index) };
}
internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, Operators op) {
if (op == Operators.None) {
return ag.AddDebugInfoAndVoid(
Binders.Set(
ag.BinderState,
typeof(object),
SymbolTable.IdToString(_name),
ag.Transform(_target),
right
),
span
);
} else {
MSAst.ParameterExpression temp = ag.GetTemporary("inplace");
return ag.AddDebugInfo(
Ast.Block(
Ast.Assign(temp, ag.Transform(_target)),
SetMemberOperator(ag, right, op, temp),
Ast.Empty()
),
Span.Start,
span.End
);
}
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return Ast.Call(
AstGenerator.GetHelperMethod("Repr"), // method
Microsoft.Scripting.Ast.Utils.CodeContext(),
ag.TransformAsObject(_expression) // args
);
}
internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, Operators op) {
MSAst.Expression variable = _reference.Variable;
MSAst.Expression assignment;
Type vt = variable != null ? variable.Type : typeof(object);
if (op != Operators.None) {
right = Binders.Operation(
ag.BinderState,
vt,
StandardOperators.FromOperator(op),
Transform(ag, vt),
right
);
}
if (variable != null) {
assignment = AstUtils.Assign(variable, AstGenerator.ConvertIfNeeded(right, variable.Type));
} else {
assignment = AstUtils.Assign(_name, right);
}
SourceSpan aspan = span.IsValid ? new SourceSpan(Span.Start, span.End) : SourceSpan.None;
return ag.AddDebugInfoAndVoid(assignment, aspan);
}
private static MSAst.Expression GetSliceValue(AstGenerator ag, Expression expr) {
if (expr != null) {
return ag.Transform(expr);
}
return Ast.Field(null, typeof(MissingParameter).GetField("Value"));
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return ag.Operation(
type,
PythonOperatorToOperatorString(_op),
ag.Transform(_expression)
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
if (ag.IsGenerator) {
if (_expression != null) {
// Statements can't return null, so return a rethrow.
// Callers should detecet the ag.AddError and avoid trying to execute the tree,
// but if they accidentally do, use Throw instead of empty so that
// we'll get an exception.
return Ast.Throw(
Ast.New(
typeof(InvalidOperationException).GetConstructor(Type.EmptyTypes)
)
);
}
return ag.AddDebugInfo(AstUtils.YieldBreak(ag.GeneratorLabel), Span);
}
return ag.AddDebugInfo(
Ast.Return(
ag.ReturnLabel,
ag.TransformOrConstantNull(_expression, typeof(object))
),
Span
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
MSAst.Expression destination = ag.TransformAsObject(_dest);
if (_expressions.Length == 0) {
MSAst.Expression result;
if (destination != null) {
result = Ast.Call(
AstGenerator.GetHelperMethod("PrintNewlineWithDest"),
ag.LocalContext,
destination
);
} else {
result = Ast.Call(
AstGenerator.GetHelperMethod("PrintNewline"),
ag.LocalContext
);
}
return ag.AddDebugInfo(result, Span);
} else {
// Create list for the individual statements
List<MSAst.Expression> statements = new List<MSAst.Expression>();
// Store destination in a temp, if we have one
if (destination != null) {
MSAst.ParameterExpression temp = ag.GetTemporary("destination");
statements.Add(
ag.MakeAssignment(temp, destination)
);
destination = temp;
}
for (int i = 0; i < _expressions.Length; i++) {
string method = (i < _expressions.Length - 1 || _trailingComma) ? "PrintComma" : "Print";
Expression current = _expressions[i];
MSAst.MethodCallExpression mce;
if (destination != null) {
mce = Ast.Call(
AstGenerator.GetHelperMethod(method + "WithDest"),
ag.LocalContext,
destination,
ag.TransformAsObject(current)
);
} else {
mce = Ast.Call(
AstGenerator.GetHelperMethod(method),
ag.LocalContext,
ag.TransformAsObject(current)
);
}
statements.Add(mce);
}
statements.Add(AstUtils.Empty());
return ag.AddDebugInfo(Ast.Block(statements.ToArray()), Span);
}
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return Ast.Call(
AstGenerator.GetHelperMethod("MakeSlice"), // method
ag.TransformOrConstantNull(_sliceStart, typeof(object)), // parameters
ag.TransformOrConstantNull(_sliceStop, typeof(object)),
ag.TransformOrConstantNull(_sliceStep, typeof(object))
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
if (_left.Length == 1) {
// Do not need temps for simple assignment
return AssignOne(ag);
} else {
return AssignComplex(ag, ag.Transform(_right));
}
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
return Binders.Operation(
ag.BinderState,
type,
GetOperatorString,
ArrayUtils.RemoveFirst(GetActionArgumentsForGetOrDelete(ag))
);
}
internal override MSAst.Expression TransformSet(AstGenerator ag, SourceSpan span, MSAst.Expression right, PythonOperationKind op) {
if (Items.Length == 0) {
ag.AddError("can't assign to ()", Span);
return null;
}
return base.TransformSet(ag, span, right, op);
}
internal override MSAst.Expression Transform(AstGenerator ag, Type type) {
MSAst.Expression func = _function.TransformToFunctionExpression(ag);
return Ast.Call(
AstGenerator.GetHelperMethod("MakeGeneratorExpression"),
func,
ag.TransformAsObject(_iterable)
);
}
internal override MSAst.Expression Transform(AstGenerator ag, MSAst.Expression body) {
return ag.AddDebugInfoAndVoid(
AstUtils.If(
ag.TransformAndDynamicConvert(_test, typeof(bool)),
body
),
Span
);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
if (ag.InFinally) {
return null;
} else if (ag.InLoop) {
return ag.AddDebugInfo(MSAst.Expression.Continue(ag.ContinueLabel), Span);
} else {
return null;
}
}
internal override MSAst.Expression Transform(AstGenerator ag) {
// Transform to series of individual del statements.
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>(_expressions.Length + 1);
for (int i = 0; i < _expressions.Length; i++) {
statements.Add(_expressions[i].TransformDelete(ag));
}
statements.Add(AstUtils.Empty());
return ag.AddDebugInfo(MSAst.Expression.Block(statements), Span);
}
internal override MSAst.Expression Transform(AstGenerator ag) {
// Transform to series of individual del statements.
MSAst.Expression[] statements = new MSAst.Expression[_expressions.Length + 1];
for (int i = 0; i < _expressions.Length; i++) {
statements[i] = _expressions[i].TransformDelete(ag);
}
statements[_expressions.Length] = AstUtils.Empty();
return ag.AddDebugInfo(MSAst.Expression.Block(statements), Span);
}
