public override MSAst.Expression Reduce() {
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])
GlobalParent.AddDebugInfoAndVoid(
AssignValue(
Parent.GetVariableExpression(_variables[i]),
LightExceptions.CheckAndThrow(
Expression.Call(
_asNames[i] == null ? AstMethods.ImportTop : AstMethods.ImportBottom,
Parent.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 GlobalParent.AddDebugInfo(Ast.Block(statements.ToReadOnlyCollection()), Span);
}
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);
}
// Just splat the args and dispatch through a nested site
public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel) {
Debug.Assert(args.Length == 2);
int count = ((object[])args[1]).Length;
ParameterExpression array = parameters[1];
var nestedArgs = new ReadOnlyCollectionBuilder<Expression>(count + 1);
var delegateArgs = new Type[count + 3]; // args + target + returnType + CallSite
nestedArgs.Add(parameters[0]);
delegateArgs[0] = typeof(CallSite);
delegateArgs[1] = typeof(object);
for (int i = 0; i < count; i++) {
nestedArgs.Add(Expression.ArrayAccess(array, Expression.Constant(i)));
delegateArgs[i + 2] = typeof(object).MakeByRefType();
}
delegateArgs[delegateArgs.Length - 1] = typeof(object);
return Expression.IfThen(
Expression.Equal(Expression.ArrayLength(array), Expression.Constant(count)),
Expression.Return(
returnLabel,
Expression.MakeDynamic(
Expression.GetDelegateType(delegateArgs),
new ComInvokeAction(new CallInfo(count)),
nestedArgs
)
)
);
}
public override MSAst.Expression Reduce() {
if (_statements.Length == 0) {
return GlobalParent.AddDebugInfoAndVoid(AstUtils.Empty(), Span);
}
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>();
int curStart = -1;
foreach (var statement in _statements) {
// CPython debugging treats multiple statements on the same line as a single step, we
// match that behavior here.
if (statement.Start.Line == curStart) {
statements.Add(new DebugInfoRemovalExpression(statement, curStart));
} else {
if (statement.CanThrow && statement.Start.IsValid) {
statements.Add(UpdateLineNumber(statement.Start.Line));
}
statements.Add(statement);
}
curStart = statement.Start.Line;
}
return Ast.Block(statements.ToReadOnlyCollection());
}
public override MSAst.Expression Reduce() {
// 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());
}
statements.Add(AstUtils.Empty());
return GlobalParent.AddDebugInfo(MSAst.Expression.Block(statements), Span);
}
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);
}
public TotemArgs(TotemContext context, string[] names, IList<object> args, Dictionary<string, object> kwargs)
: base(context.GetType<Types.Arguments>())
{
_names = new ReadOnlyCollectionBuilder<string>(names).ToReadOnlyCollection();
var vb = new ReadOnlyCollectionBuilder<object>();
var nvb = new Dictionary<string, object>();
var snb = new ReadOnlyCollectionBuilder<string>();
for (var i = 0; i < args.Count; i++)
{
vb.Add(args[i]);
if (i < names.Length)
nvb.Add(names[i], args[i]);
}
foreach (var arg in kwargs)
{
nvb.Add(arg.Key, arg.Value);
snb.Add(arg.Key);
}
_values = vb.ToReadOnlyCollection();
_namedValues = new ReadOnlyDictionary<string, object>(nvb);
_named = snb.ToReadOnlyCollection();
}
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
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>();
// Store destination in a temp, if we have one
if (destination != null) {
MSAst.ParameterExpression temp = ag.GetTemporary("destination");
statements.Add(
AstGenerator.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.ToReadOnlyCollection()), Span);
}
}
private readonly static Expression[] s_noArgs = new Expression[0]; // used in reference comparison, requires unique object identity
private static Expression[] GetConvertedArgs(params Expression[] args)
{
ReadOnlyCollectionBuilder <Expression> paramArgs = new ReadOnlyCollectionBuilder <Expression>(args.Length);
for (int i = 0; i < args.Length; i++)
{
paramArgs.Add(Expression.Convert(args[i], typeof(object)));
}
return(paramArgs.ToArray());
}
public void ReadOnlyCollectionBuilder_Add()
{
var rocb = new ReadOnlyCollectionBuilder <int>();
for (int i = 1; i <= 10; i++)
{
rocb.Add(i);
Assert.True(Enumerable.Range(1, i).SequenceEqual(rocb));
}
}
protected internal static MSAst.BlockExpression UnpackSequenceHelper <T>(IList <Expression> items, MethodInfo makeEmpty, MethodInfo append, MethodInfo extend)
{
var expressions = new ReadOnlyCollectionBuilder <MSAst.Expression>(items.Count + 2);
var varExpr = Expression.Variable(typeof(T), "$coll");
expressions.Add(Expression.Assign(varExpr, Expression.Call(makeEmpty)));
foreach (var item in items)
{
if (item is StarredExpression starredExpression)
{
expressions.Add(Expression.Call(extend, varExpr, AstUtils.Convert(starredExpression.Value, typeof(object))));
}
else
{
expressions.Add(Expression.Call(append, varExpr, AstUtils.Convert(item, typeof(object))));
}
}
expressions.Add(varExpr);
return(Expression.Block(typeof(T), new MSAst.ParameterExpression[] { varExpr }, expressions));
}
private void AddInitialization(ReadOnlyCollectionBuilder <MSAst.Expression> block)
{
if (IsModule)
{
block.Add(AssignValue(GetVariableExpression(FileVariable), Ast.Constant(ModuleFileName)));
block.Add(AssignValue(GetVariableExpression(NameVariable), Ast.Constant(ModuleName)));
block.Add(AssignValue(GetVariableExpression(SpecVariable), Ast.Constant(null)));
}
if (_languageFeatures != ModuleOptions.None || IsModule)
{
block.Add(
Ast.Call(
AstMethods.ModuleStarted,
LocalContext,
AstUtils.Constant(_languageFeatures)
)
);
}
}
public override System.Linq.Expressions.Expression Reduce()
{
if (_statements.Length == 0)
return GlobalParent.AddDebugInfoAndVoid(AstUtils.Empty(), Span);
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>();
foreach (var stmt in _statements)
{
var line = GlobalParent.IndexToLocation(stmt.StartIndex).Line;
if (stmt.CanThrow && line != -1)
{
statements.Add(UpdateLineNumber(line));
}
statements.Add(stmt);
}
return Ast.Block(statements.ToReadOnlyCollection());
}
internal Func <object[], StrongBox <object>[], InterpretedFrame, int> CreateDelegate()
{
Expression body = this.Visit(this._loop);
ReadOnlyCollectionBuilder <Expression> expressions = new ReadOnlyCollectionBuilder <Expression>();
ReadOnlyCollectionBuilder <Expression> builder2 = new ReadOnlyCollectionBuilder <Expression>();
foreach (KeyValuePair <ParameterExpression, LoopVariable> pair in this._loopVariables)
{
LocalVariable variable;
if (!this._outerVariables.TryGetValue(pair.Key, out variable))
{
variable = this._closureVariables[pair.Key];
}
Expression right = variable.LoadFromArray(this._frameDataVar, this._frameClosureVar);
if (variable.InClosureOrBoxed)
{
ParameterExpression boxStorage = pair.Value.BoxStorage;
expressions.Add(Expression.Assign(boxStorage, right));
this.AddTemp(boxStorage);
}
else
{
expressions.Add(Expression.Assign(pair.Key, Utils.Convert(right, pair.Key.Type)));
if ((pair.Value.Access & ExpressionAccess.Write) != ExpressionAccess.None)
{
builder2.Add(Expression.Assign(right, Utils.Box(pair.Key)));
}
this.AddTemp(pair.Key);
}
}
if (builder2.Count > 0)
{
expressions.Add(Expression.TryFinally(body, Expression.Block(builder2)));
}
else
{
expressions.Add(body);
}
expressions.Add(Expression.Label(this._returnLabel, Expression.Constant(this._loopEndInstructionIndex - this._loopStartInstructionIndex)));
return(Expression.Lambda <Func <object[], StrongBox <object>[], InterpretedFrame, int> >((this._temps != null) ? Expression.Block((IEnumerable <ParameterExpression>) this._temps.ToReadOnlyCollection(), (IEnumerable <Expression>)expressions) : Expression.Block(expressions), new ParameterExpression[] { this._frameDataVar, this._frameClosureVar, this._frameVar }).Compile());
}
internal void CreateVariables(ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
if (Variables != null) {
foreach (PythonVariable variable in Variables.Values) {
if (variable.Kind != VariableKind.Global) {
ClosureExpression closure = GetVariableExpression(variable) as ClosureExpression;
if (closure != null) {
init.Add(closure.Create());
locals.Add((MSAst.ParameterExpression)closure.ClosureCell);
} else if (variable.Kind == VariableKind.Local) {
locals.Add((MSAst.ParameterExpression)GetVariableExpression(variable));
if (variable.ReadBeforeInitialized) {
init.Add(
AssignValue(
GetVariableExpression(variable),
MSAst.Expression.Field(null, typeof(Uninitialized).GetField("Instance"))
)
);
}
}
}
}
}
if (IsClosure) {
Type tupleType = Parent.GetClosureTupleType();
Debug.Assert(tupleType != null);
init.Add(
MSAst.Expression.Assign(
LocalParentTuple,
MSAst.Expression.Convert(
GetParentClosureTuple(),
tupleType
)
)
);
locals.Add(LocalParentTuple);
}
}
internal LoopFunc CreateDelegate()
{
var loop = (LoopExpression)Visit(_loop);
var body = new ReadOnlyCollectionBuilder <Expression>();
var finallyClause = new ReadOnlyCollectionBuilder <Expression>();
foreach (var variable in _loopVariables)
{
LocalVariable local = _locals[variable.Key];
Expression elemRef = local.LoadFromArray(_frameDataVar, _frameClosureVar);
if (local.InClosureOrBoxed)
{
var box = variable.Value.BoxStorage;
Debug.Assert(box != null);
body.Add(Expression.Assign(box, elemRef));
AddTemp(box);
}
else
{
// Always initialize the variable even if it is only written to.
// If a write-only variable is actually not assigned during execution of the loop we will still write some value back.
// This value must be the original value, which we assign at entry.
body.Add(Expression.Assign(variable.Key, AstUtils.Convert(elemRef, variable.Key.Type)));
if ((variable.Value.Access & ExpressionAccess.Write) != 0)
{
finallyClause.Add(Expression.Assign(elemRef, AstUtils.Box(variable.Key)));
}
AddTemp(variable.Key);
}
}
if (finallyClause.Count > 0)
{
body.Add(Expression.TryFinally(loop, Expression.Block(finallyClause)));
}
else
{
body.Add(loop);
}
body.Add(Expression.Label(_returnLabel, Expression.Constant(_loopEndInstructionIndex - _loopStartInstructionIndex)));
var lambda = Expression.Lambda <LoopFunc>(
_temps != null ? Expression.Block(_temps.ToReadOnlyCollection(), body) : Expression.Block(body),
new[] { _frameDataVar, _frameClosureVar, _frameVar }
);
return(lambda.Compile());
}
public void ReadOnlyCollectionBuilder_ToArray(int length)
{
var rocb = new ReadOnlyCollectionBuilder <int>();
for (int i = 0; i < length; i++)
{
rocb.Add(i);
}
int[] array = rocb.ToArray();
Assert.True(Enumerable.Range(0, length).SequenceEqual(array));
}
private Expression VisitYield(YieldExpression node)
{
if (node.Target != _generator.Target)
{
throw new InvalidOperationException("yield and generator must have the same LabelTarget object");
}
var value = Visit(node.Value);
var block = new ReadOnlyCollectionBuilder <Expression>();
if (value == null)
{
// Yield break
block.Add(Expression.Assign(_state, AstUtils.Constant(Finished)));
if (_inTryWithFinally)
{
block.Add(Expression.Assign(_gotoRouter, AstUtils.Constant(GotoRouterYielding)));
}
block.Add(Expression.Goto(_returnLabels.Peek()));
return(Expression.Block(block));
}
// Yield return
block.Add(MakeAssign(_current, value));
YieldMarker marker = GetYieldMarker(node);
block.Add(Expression.Assign(_state, AstUtils.Constant(marker.State)));
if (_inTryWithFinally)
{
block.Add(Expression.Assign(_gotoRouter, AstUtils.Constant(GotoRouterYielding)));
}
block.Add(Expression.Goto(_returnLabels.Peek()));
block.Add(Expression.Label(marker.Label));
block.Add(Expression.Assign(_gotoRouter, AstUtils.Constant(GotoRouterNone)));
block.Add(Utils.Empty());
return(Expression.Block(block));
}
private Expression ToTemp(ReadOnlyCollectionBuilder <Expression> block, Expression e)
{
Debug.Assert(e != null);
if (IsConstant(e))
{
return(e);
}
var temp = Expression.Variable(e.Type, "generatorTemp" + _temps.Count);
_temps.Add(temp);
block.Add(MakeAssign(temp, e));
return(temp);
}
public void ReadOnlyCollectionBuilder_ToReadOnlyCollection(int length)
{
var rocb = new ReadOnlyCollectionBuilder <int>();
for (int i = 0; i < length; i++)
{
rocb.Add(i);
}
ReadOnlyCollection <int> collection = rocb.ToReadOnlyCollection();
Assert.Equal(length, collection.Count);
Assert.True(Enumerable.Range(0, length).SequenceEqual(collection));
AssertEmpty(rocb);
}
// We need to rewrite unary expressions as well since ETs don't support jumping into unary expressions.
private Expression Rewrite(Expression node, Expression expr, Func <Expression, Expression> factory)
{
int yields = _yields.Count;
Expression newExpr = Visit(expr);
if (newExpr == expr)
{
return(node);
}
if (yields == _yields.Count || IsConstant(newExpr))
{
return(factory(newExpr));
}
var block = new ReadOnlyCollectionBuilder <Expression>(2);
newExpr = ToTemp(block, newExpr);
block.Add(factory(newExpr));
return(Expression.Block(block));
}
private MSAst.ParameterExpression[] CreateParameters(bool needsWrapperMethod, ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals)
{
MSAst.ParameterExpression[] parameters;
if (needsWrapperMethod)
{
parameters = new[] { _functionParam, Ast.Parameter(typeof(object[]), "allArgs") };
foreach (var param in _parameters)
{
locals.Add(param.ParameterExpression);
}
}
else
{
parameters = new MSAst.ParameterExpression[_parameters.Length + 1];
for (int i = 1; i < parameters.Length; i++)
{
parameters[i] = _parameters[i - 1].ParameterExpression;
}
parameters[0] = _functionParam;
}
return(parameters);
}
internal override void FinishBind(TotemNameBinder binder)
{
if (_freeVars != null && _freeVars.Count > 0)
{
ReadOnlyCollectionBuilder<TotemVariable> closureVariables = new ReadOnlyCollectionBuilder<TotemVariable>();
_closureType = MutableTuple.MakeTupleType(_freeVars.Select(v => typeof(ClosureCell)).ToArray());
_localClosureTuple = Expression.Parameter(_closureType, "$closure");
for (var i = 0; i < _freeVars.Count; i++)
{
var variable = _freeVars[i];
_variableMapping[variable] = new ClosureExpression(variable, Expression.Property(_localClosureTuple, String.Format("Item{0:D3}", i)), null);
closureVariables.Add(variable);
}
_closureVariables = closureVariables.ToReadOnlyCollection();
}
if (_scopeVars != null)
foreach (var local in _scopeVars)
{
if (local.Kind == VariableKind.Parameter) // handled in subclass
continue;
// scope variables, defined in this scope
Debug.Assert(local.Kind == VariableKind.Local);
Debug.Assert(local.Scope == this);
if (local.AccessedInNestedScope)
{
// Closure variable
_variableMapping[local] = new ClosureExpression(local, Expression.Parameter(typeof(ClosureCell), local.Name), null);
}
else
{
// Not used in nested function-scopes
_variableMapping[local] = Expression.Parameter(typeof(object), local.Name);
}
}
}
/// <summary>
/// Helper method for generating expressions that assign byRef call
/// parameters back to their original variables.
/// </summary>
private static Expression ReferenceArgAssign(Expression callArgs, Expression[] args)
{
ReadOnlyCollectionBuilder <Expression>?block = null;
for (int i = 0; i < args.Length; i++)
{
ParameterExpression?variable = args[i] as ParameterExpression;
ContractUtils.Requires(variable != null, nameof(args));
if (variable.IsByRef)
{
block ??= new ReadOnlyCollectionBuilder <Expression>();
block.Add(
Expression.Assign(
variable,
Expression.Convert(
Expression.ArrayIndex(
callArgs,
AstUtils.Constant(i)
),
variable.Type
)
)
);
}
}
if (block != null)
{
return(Expression.Block(block));
}
else
{
return(AstUtils.Empty);
}
}
public override MSAst.Expression Reduce()
{
MSAst.Expression destination = _dest;
if (_expressions.Length == 0)
{
MSAst.Expression result;
if (destination != null)
{
result = Ast.Call(
AstMethods.PrintNewlineWithDest,
Parent.LocalContext,
destination
);
}
else
{
result = Ast.Call(
AstMethods.PrintNewline,
Parent.LocalContext
);
}
return(GlobalParent.AddDebugInfo(result, Span));
}
else
{
// Create list for the individual statements
ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>();
// Store destination in a temp, if we have one
MSAst.ParameterExpression temp = null;
if (destination != null)
{
temp = Ast.Variable(typeof(object), "destination");
statements.Add(MakeAssignment(temp, destination));
destination = temp;
}
for (int i = 0; i < _expressions.Length; i++)
{
bool withComma = (i < _expressions.Length - 1 || _trailingComma);// ? "PrintComma" : "Print";
Expression current = _expressions[i];
MSAst.MethodCallExpression mce;
if (destination != null)
{
mce = Ast.Call(
withComma ? AstMethods.PrintCommaWithDest : AstMethods.PrintWithDest,
Parent.LocalContext,
destination,
AstUtils.Convert(current, typeof(object))
);
}
else
{
mce = Ast.Call(
withComma ? AstMethods.PrintComma : AstMethods.Print,
Parent.LocalContext,
AstUtils.Convert(current, typeof(object))
);
}
statements.Add(mce);
}
statements.Add(AstUtils.Empty());
MSAst.Expression res;
if (temp != null)
{
res = Ast.Block(new[] { temp }, statements.ToReadOnlyCollection());
}
else
{
res = Ast.Block(statements.ToReadOnlyCollection());
}
return(GlobalParent.AddDebugInfo(res, Span));
}
}
/// <summary>
/// WithStatement is translated to the DLR AST equivalent to
/// the following Python code snippet (from with statement spec):
///
/// mgr = (EXPR)
/// exit = mgr.__exit__ # Not calling it yet
/// value = mgr.__enter__()
/// exc = True
/// try:
/// VAR = value # Only if "as VAR" is present
/// BLOCK
/// except:
/// # The exceptional case is handled here
/// exc = False
/// if not exit(*sys.exc_info()):
/// raise
/// # The exception is swallowed if exit() returns true
/// finally:
/// # The normal and non-local-goto cases are handled here
/// if exc:
/// exit(None, None, None)
///
/// </summary>
public override MSAst.Expression Reduce() {
// Five statements in the result...
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>(6);
ReadOnlyCollectionBuilder<MSAst.ParameterExpression> variables = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>(6);
MSAst.ParameterExpression lineUpdated = Ast.Variable(typeof(bool), "$lineUpdated_with");
variables.Add(lineUpdated);
//******************************************************************
// 1. mgr = (EXPR)
//******************************************************************
MSAst.ParameterExpression manager = Ast.Variable(typeof(object), "with_manager");
variables.Add(manager);
statements.Add(
GlobalParent.AddDebugInfo(
Ast.Assign(
manager,
_contextManager
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 2. exit = mgr.__exit__ # Not calling it yet
//******************************************************************
MSAst.ParameterExpression exit = Ast.Variable(typeof(object), "with_exit");
variables.Add(exit);
statements.Add(
MakeAssignment(
exit,
GlobalParent.Get(
"__exit__",
manager
)
)
);
//******************************************************************
// 3. value = mgr.__enter__()
//******************************************************************
MSAst.ParameterExpression value = Ast.Variable(typeof(object), "with_value");
variables.Add(value);
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
MakeAssignment(
value,
Parent.Invoke(
new CallSignature(0),
Parent.LocalContext,
GlobalParent.Get(
"__enter__",
manager
)
)
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 4. exc = True
//******************************************************************
MSAst.ParameterExpression exc = Ast.Variable(typeof(bool), "with_exc");
variables.Add(exc);
statements.Add(
MakeAssignment(
exc,
AstUtils.Constant(true)
)
);
//******************************************************************
// 5. The final try statement:
//
// try:
// VAR = value # Only if "as VAR" is present
// BLOCK
// except:
// # The exceptional case is handled here
// exc = False
// if not exit(*sys.exc_info()):
// raise
// # The exception is swallowed if exit() returns true
// finally:
// # The normal and non-local-goto cases are handled here
// if exc:
// exit(None, None, None)
//******************************************************************
MSAst.ParameterExpression exception;
MSAst.ParameterExpression nestedFrames = Ast.Variable(typeof(List<DynamicStackFrame>), "$nestedFrames");
variables.Add(nestedFrames);
statements.Add(
// try:
AstUtils.Try(
AstUtils.Try(// try statement body
PushLineUpdated(false, lineUpdated),
_var != null ?
(MSAst.Expression)Ast.Block(
// VAR = value
_var.TransformSet(SourceSpan.None, value, PythonOperationKind.None),
// BLOCK
_body,
AstUtils.Empty()
) :
// BLOCK
(MSAst.Expression)_body // except:, // try statement location
).Catch(exception = Ast.Variable(typeof(Exception), "exception"),
// Python specific exception handling code
TryStatement.GetTracebackHeader(
this,
exception,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
// exc = False
MakeAssignment(
exc,
AstUtils.Constant(false)
),
Ast.Assign(
nestedFrames,
Ast.Call(AstMethods.GetAndClearDynamicStackFrames)
),
// if not exit(*sys.exc_info()):
// raise
AstUtils.IfThen(
GlobalParent.Convert(
typeof(bool),
ConversionResultKind.ExplicitCast,
GlobalParent.Operation(
typeof(bool),
PythonOperationKind.IsFalse,
MakeExitCall(exit, exception)
)
),
UpdateLineUpdated(true),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
Ast.Throw(
Ast.Call(
AstMethods.MakeRethrowExceptionWorker,
exception
)
)
)
),
_body.Span
)
),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
PopLineUpdated(lineUpdated),
Ast.Empty()
)
// finally:
).Finally(
// if exc:
// exit(None, None, None)
AstUtils.IfThen(
exc,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
Ast.Dynamic(
GlobalParent.PyContext.Invoke(
new CallSignature(3) // signature doesn't include function
),
typeof(object),
new MSAst.Expression[] {
Parent.LocalContext,
exit,
AstUtils.Constant(null),
AstUtils.Constant(null),
AstUtils.Constant(null)
}
),
Ast.Empty()
),
_contextManager.Span
)
)
)
);
statements.Add(AstUtils.Empty());
return Ast.Block(variables.ToReadOnlyCollection(), statements.ToReadOnlyCollection());
}
/// <summary>
/// Creates the LambdaExpression which implements the body of the function.
///
/// The functions signature is either "object Function(PythonFunction, ...)"
/// where there is one object parameter for each user defined parameter or
/// object Function(PythonFunction, object[]) for functions which take more
/// than PythonCallTargets.MaxArgs arguments.
/// </summary>
private LightLambdaExpression CreateFunctionLambda()
{
bool needsWrapperMethod = _parameters.Length > PythonCallTargets.MaxArgs;
Delegate originalDelegate;
Type delegateType = GetDelegateType(_parameters, needsWrapperMethod, out originalDelegate);
MSAst.ParameterExpression localContext = null;
ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>();
if (NeedsLocalContext)
{
localContext = LocalCodeContextVariable;
locals.Add(localContext);
}
MSAst.ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);
List <MSAst.Expression> init = new List <MSAst.Expression>();
foreach (var param in _parameters)
{
IPythonVariableExpression pyVar = GetVariableExpression(param.PythonVariable) as IPythonVariableExpression;
if (pyVar != null)
{
var varInit = pyVar.Create();
if (varInit != null)
{
init.Add(varInit);
}
}
}
// Transform the parameters.
init.Add(Ast.ClearDebugInfo(GlobalParent.Document));
locals.Add(PythonAst._globalContext);
init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContext)));
GlobalParent.PrepareScope(locals, init);
// Create variables and references. Since references refer to
// parameters, do this after parameters have been created.
CreateFunctionVariables(locals, init);
// If the __class__ variable is used the a class method then we need to initialize it.
// This must be done before parameter initialization (in case one of the parameters is called __class__).
ClassDefinition parent = FindParentOfType <ClassDefinition>();
PythonVariable pVar;
if (parent != null && TryGetVariable("__class__", out pVar))
{
init.Add(
AssignValue(
GetVariableExpression(pVar),
Ast.Call(AstMethods.LookupName, parent.Parent.LocalContext, Ast.Constant(parent.Name))
)
);
}
// Initialize parameters - unpack tuples.
// Since tuples unpack into locals, this must be done after locals have been created.
InitializeParameters(init, needsWrapperMethod, parameters);
List <MSAst.Expression> statements = new List <MSAst.Expression>();
// add beginning sequence point
var start = GlobalParent.IndexToLocation(StartIndex);
statements.Add(GlobalParent.AddDebugInfo(
AstUtils.Empty(),
new SourceSpan(new SourceLocation(0, start.Line, start.Column), new SourceLocation(0, start.Line, Int32.MaxValue))));
// For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
// The exception traceback needs to come from the generator's method body, and so we must do the check and throw
// from inside the generator.
if (IsGenerator)
{
MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
statements.Add(s1);
}
MSAst.ParameterExpression extracted = null;
if (!IsGenerator && _canSetSysExcInfo)
{
// need to allocate the exception here so we don't share w/ exceptions made & freed
// during the body.
extracted = Ast.Parameter(typeof(Exception), "$ex");
locals.Add(extracted);
}
if (_body.CanThrow && !(_body is SuiteStatement) && _body.StartIndex != -1)
{
statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(_body.StartIndex).Line));
}
statements.Add(Body);
MSAst.Expression body = Ast.Block(statements);
// If this function can modify sys.exc_info() (_canSetSysExcInfo), then it must restore the result on finish.
//
// Wrap in
// $temp = PythonOps.SaveCurrentException()
// <body>
// PythonOps.RestoreCurrentException($temp)
// Skip this if we're a generator. For generators, the try finally is handled by the PythonGenerator class
// before it's invoked. This is because the restoration must occur at every place the function returns from
// a yield point. That's different than the finally semantics in a generator.
if (extracted != null)
{
MSAst.Expression s = AstUtils.Try(
Ast.Assign(
extracted,
Ast.Call(AstMethods.SaveCurrentException)
),
body
).Finally(
Ast.Call(
AstMethods.RestoreCurrentException, extracted
)
);
body = s;
}
if (_body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames)
{
body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(PythonFunction).GetProperty("__code__")), body);
locals.Add(FunctionStackVariable);
}
body = AddProfiling(body);
body = WrapScopeStatements(body, _body.CanThrow);
body = Ast.Block(body, AstUtils.Empty());
body = AddReturnTarget(body);
MSAst.Expression bodyStmt = body;
if (localContext != null)
{
var createLocal = CreateLocalContext(_parentContext);
init.Add(
Ast.Assign(
localContext,
createLocal
)
);
}
init.Add(bodyStmt);
bodyStmt = Ast.Block(init);
// wrap a scope if needed
bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);
return(AstUtils.LightLambda(
typeof(object),
delegateType,
AddDefaultReturn(bodyStmt, typeof(object)),
Name + "$" + Interlocked.Increment(ref _lambdaId),
parameters
));
}
private static ReadOnlyCollectionBuilder<MSAst.ParameterExpression> GetVariables(MSAst.ParameterExpression lineUpdated, MSAst.ParameterExpression runElse) {
var paramList = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
if(lineUpdated != null) {
paramList.Add(lineUpdated);
}
if(runElse != null) {
paramList.Add(runElse);
}
return paramList;
}
public override void PrepareScope(PythonAst ast, ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
locals.Add(PythonAst._globalArray);
init.Add(Ast.Assign(PythonAst._globalArray, ast._arrayExpression));
}
/// <summary>
/// Creates the LambdaExpression which implements the body of the function.
///
/// The functions signature is either "object Function(PythonFunction, ...)"
/// where there is one object parameter for each user defined parameter or
/// object Function(PythonFunction, object[]) for functions which take more
/// than PythonCallTargets.MaxArgs arguments.
/// </summary>
private LightLambdaExpression CreateFunctionLambda()
{
bool needsWrapperMethod = _parameters.Length > PythonCallTargets.MaxArgs;
Type delegateType = GetDelegateType(_parameters, needsWrapperMethod, out _);
MSAst.ParameterExpression localContext = null;
ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>();
if (NeedsLocalContext)
{
localContext = LocalCodeContextVariable;
locals.Add(localContext);
}
MSAst.ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);
List <MSAst.Expression> init = new List <MSAst.Expression>();
foreach (var param in _parameters)
{
if (GetVariableExpression(param.PythonVariable) is IPythonVariableExpression pyVar)
{
var varInit = pyVar.Create();
if (varInit != null)
{
init.Add(varInit);
}
}
}
// Transform the parameters.
init.Add(Ast.ClearDebugInfo(GlobalParent.Document));
locals.Add(PythonAst._globalContext);
init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContext)));
GlobalParent.PrepareScope(locals, init);
// Create variables and references. Since references refer to
// parameters, do this after parameters have been created.
CreateFunctionVariables(locals, init);
// Initialize parameters - unpack tuples.
// Since tuples unpack into locals, this must be done after locals have been created.
InitializeParameters(init, needsWrapperMethod, parameters);
List <MSAst.Expression> statements = new List <MSAst.Expression>();
// add beginning sequence point
var start = GlobalParent.IndexToLocation(StartIndex);
statements.Add(GlobalParent.AddDebugInfo(
AstUtils.Empty(),
new SourceSpan(new SourceLocation(0, start.Line, start.Column), new SourceLocation(0, start.Line, int.MaxValue))));
// For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
// The exception traceback needs to come from the generator's method body, and so we must do the check and throw
// from inside the generator.
if (IsGenerator)
{
MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
statements.Add(s1);
}
if (Body.CanThrow && !(Body is SuiteStatement) && Body.StartIndex != -1)
{
statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(Body.StartIndex).Line));
}
statements.Add(Body);
MSAst.Expression body = Ast.Block(statements);
if (Body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames)
{
body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(PythonFunction).GetProperty(nameof(PythonFunction.__code__))), body);
locals.Add(FunctionStackVariable);
}
body = AddProfiling(body);
body = WrapScopeStatements(body, Body.CanThrow);
body = Ast.Block(body, AstUtils.Empty());
body = AddReturnTarget(body);
MSAst.Expression bodyStmt = body;
if (localContext != null)
{
var createLocal = CreateLocalContext(_parentContext);
init.Add(
Ast.Assign(
localContext,
createLocal
)
);
}
init.Add(bodyStmt);
bodyStmt = Ast.Block(init);
// wrap a scope if needed
bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);
return(AstUtils.LightLambda(
typeof(object),
delegateType,
AddDefaultReturn(bodyStmt, typeof(object)),
Name + "$" + Interlocked.Increment(ref _lambdaId),
parameters
));
}
/// <summary>
/// WithStatement is translated to the DLR AST equivalent to
/// the following Python code snippet (from with statement spec):
///
/// mgr = (EXPR)
/// exit = mgr.__exit__ # Not calling it yet
/// value = mgr.__enter__()
/// exc = True
/// try:
/// VAR = value # Only if "as VAR" is present
/// BLOCK
/// except:
/// # The exceptional case is handled here
/// exc = False
/// if not exit(*sys.exc_info()):
/// raise
/// # The exception is swallowed if exit() returns true
/// finally:
/// # The normal and non-local-goto cases are handled here
/// if exc:
/// exit(None, None, None)
///
/// </summary>
public override MSAst.Expression Reduce()
{
// Five statements in the result...
ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>(6);
ReadOnlyCollectionBuilder <MSAst.ParameterExpression> variables = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>(6);
MSAst.ParameterExpression lineUpdated = Ast.Variable(typeof(bool), "$lineUpdated_with");
variables.Add(lineUpdated);
//******************************************************************
// 1. mgr = (EXPR)
//******************************************************************
MSAst.ParameterExpression manager = Ast.Variable(typeof(object), "with_manager");
variables.Add(manager);
statements.Add(
GlobalParent.AddDebugInfo(
Ast.Assign(
manager,
_contextManager
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 2. exit = mgr.__exit__ # Not calling it yet
//******************************************************************
MSAst.ParameterExpression exit = Ast.Variable(typeof(object), "with_exit");
variables.Add(exit);
statements.Add(
MakeAssignment(
exit,
GlobalParent.Get(
"__exit__",
manager
)
)
);
//******************************************************************
// 3. value = mgr.__enter__()
//******************************************************************
MSAst.ParameterExpression value = Ast.Variable(typeof(object), "with_value");
variables.Add(value);
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
MakeAssignment(
value,
Parent.Invoke(
new CallSignature(0),
Parent.LocalContext,
GlobalParent.Get(
"__enter__",
manager
)
)
),
new SourceSpan(Start, _header)
)
);
//******************************************************************
// 4. exc = True
//******************************************************************
MSAst.ParameterExpression exc = Ast.Variable(typeof(bool), "with_exc");
variables.Add(exc);
statements.Add(
MakeAssignment(
exc,
AstUtils.Constant(true)
)
);
//******************************************************************
// 5. The final try statement:
//
// try:
// VAR = value # Only if "as VAR" is present
// BLOCK
// except:
// # The exceptional case is handled here
// exc = False
// if not exit(*sys.exc_info()):
// raise
// # The exception is swallowed if exit() returns true
// finally:
// # The normal and non-local-goto cases are handled here
// if exc:
// exit(None, None, None)
//******************************************************************
MSAst.ParameterExpression exception;
MSAst.ParameterExpression nestedFrames = Ast.Variable(typeof(List <DynamicStackFrame>), "$nestedFrames");
variables.Add(nestedFrames);
statements.Add(
// try:
AstUtils.Try(
AstUtils.Try(// try statement body
PushLineUpdated(false, lineUpdated),
_var != null ?
(MSAst.Expression)Ast.Block(
// VAR = value
_var.TransformSet(SourceSpan.None, value, PythonOperationKind.None),
// BLOCK
_body,
AstUtils.Empty()
) :
// BLOCK
(MSAst.Expression)_body // except:, // try statement location
).Catch(exception = Ast.Variable(typeof(Exception), "exception"),
// Python specific exception handling code
TryStatement.GetTracebackHeader(
this,
exception,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
// exc = False
MakeAssignment(
exc,
AstUtils.Constant(false)
),
Ast.Assign(
nestedFrames,
Ast.Call(AstMethods.GetAndClearDynamicStackFrames)
),
// if not exit(*sys.exc_info()):
// raise
AstUtils.IfThen(
GlobalParent.Convert(
typeof(bool),
ConversionResultKind.ExplicitCast,
GlobalParent.Operation(
typeof(bool),
PythonOperationKind.IsFalse,
MakeExitCall(exit, exception)
)
),
UpdateLineUpdated(true),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
Ast.Throw(
Ast.Call(
AstMethods.MakeRethrowExceptionWorker,
exception
)
)
)
),
_body.Span
)
),
Ast.Call(
AstMethods.SetDynamicStackFrames,
nestedFrames
),
PopLineUpdated(lineUpdated),
Ast.Empty()
)
// finally:
).Finally(
// if exc:
// exit(None, None, None)
AstUtils.IfThen(
exc,
GlobalParent.AddDebugInfoAndVoid(
Ast.Block(
Ast.Dynamic(
GlobalParent.PyContext.Invoke(
new CallSignature(3) // signature doesn't include function
),
typeof(object),
new MSAst.Expression[] {
Parent.LocalContext,
exit,
AstUtils.Constant(null),
AstUtils.Constant(null),
AstUtils.Constant(null)
}
),
Ast.Empty()
),
_contextManager.Span
)
)
)
);
statements.Add(AstUtils.Empty());
return(Ast.Block(variables.ToReadOnlyCollection(), statements.ToReadOnlyCollection()));
}
//internal static Func<TotemFunction, TotemArgs, object> FunctionDelegate = new Func<TotemFunction, TotemArgs, object>((fn, args) =>
//{
// fn.Code.LazyCompileFirstTarget(fn);
// return ((Func<TotemFunction, TotemArgs, object>)fn.Code.Target)(fn, args);
//});
/// <summary>
/// Creates the LambdaExpression which implements the body of the function.
///
/// The functions signature is either "object Function(PythonFunction, ...)"
/// where there is one object parameter for each user defined parameter or
/// object Function(PythonFunction, object[]) for functions which take more
/// than PythonCallTargets.MaxArgs arguments.
/// </summary>
private LightLambdaExpression CreateFunctionLambda()
{
Type delegateType = typeof(Func<TotemFunction, TotemArgs, object>);
MSAst.ParameterExpression localContext = null;
ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
if (NeedsLocalContext || CanThrow)
{
localContext = LocalCodeContextVariable;
locals.Add(localContext);
}
MSAst.ParameterExpression[] parameters = CreateParameters(locals);
List<MSAst.Expression> init = new List<Ast>();
foreach (var param in _parameters)
{
ITotemVariableExpression toVar = GetVariableExpression(param.TotemVariable) as ITotemVariableExpression;
if (toVar != null)
{
var varInit = toVar.Create();
if (varInit != null)
init.Add(varInit);
}
}
// Transform the parameters.
init.Add(Ast.ClearDebugInfo(GlobalParent.Document));
locals.Add(TotemAst._globalContext);
init.Add(Ast.Assign(TotemAst._globalContext, new GetGlobalContextExpression(_parentContext)));
GlobalParent.PrepareScope(locals, init);
// Create variables and references. Since references refer to
// parameters, do this after parameters have been created.
CreateFunctionVariables(locals, init);
// Initialize parameters - unpack tuples.
// Since tuples unpack into locals, this must be done after locals have been created.
InitializeParameters(init, parameters);
List<MSAst.Expression> statements = new List<MSAst.Expression>();
// add beginning sequence point
var start = GlobalParent.IndexToLocation(StartIndex);
statements.Add(
GlobalParent.AddDebugInfo(
AstUtils.Empty(),
new SourceSpan(new SourceLocation(0, start.Line, start.Column), new SourceLocation(0, start.Line, Int32.MaxValue)) // TODO: augment, not correct for totem
)
);
// For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
// The exception traceback needs to come from the generator's method body, and so we must do the check and throw
// from inside the generator.
if (IsGenerator)
{
//throw new NotImplementedException();
//MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
//statements.Add(s1);
}
if (_body.CanThrow && !(_body is SuiteStatement) && _body.StartIndex != -1)
{
statements.Add(UpdateLineNumber(GlobalParent.IndexToLocation(_body.StartIndex).Line));
}
statements.Add(Body);
MSAst.Expression body = Ast.Block(statements);
if (_body.CanThrow && GlobalParent.TotemContext.TotemOptions.Frames)
{
//body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(TotemFunction).GetProperty("Code")), body);
locals.Add(FunctionStackVariable);
}
body = AddProfiling(body);
body = WrapScopeStatements(body, _body.CanThrow);
body = Ast.Block(body, Ast.Empty());
body = AddReturnTarget(body);
MSAst.Expression bodyStmt = body;
if (localContext != null)
{
var createLocal = CreateLocalContext(_parentContext);
init.Add(
Ast.Assign(
localContext,
createLocal
)
);
}
init.Add(bodyStmt);
bodyStmt = Ast.Block(init);
// wrap a scope if needed
bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);
return AstUtils.LightLambda(
typeof(object),
delegateType,
AddDefaultReturn(bodyStmt, typeof(object)),
Name + "$" + Interlocked.Increment(ref _lambdaId),
parameters
);
}
private Microsoft.Scripting.Ast.LightExpression <Func <CodeContext, CodeContext> > MakeClassBody()
{
// we always need to create a nested context for class defs
var init = new List <MSAst.Expression>();
var locals = new ReadOnlyCollectionBuilder <MSAst.ParameterExpression>();
locals.Add(LocalCodeContextVariable);
locals.Add(PythonAst._globalContext);
init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContextParam)));
GlobalParent.PrepareScope(locals, init);
CreateVariables(locals, init);
var createLocal = CreateLocalContext(_parentContextParam);
init.Add(Ast.Assign(LocalCodeContextVariable, createLocal));
List <MSAst.Expression> statements = new List <MSAst.Expression>();
// Create the body
MSAst.Expression bodyStmt = _body;
// __module__ = __name__
MSAst.Expression modStmt = AssignValue(GetVariableExpression(_modVariable), GetVariableExpression(_modNameVariable));
string doc = GetDocumentation(_body);
if (doc != null)
{
statements.Add(
AssignValue(
GetVariableExpression(_docVariable),
AstUtils.Constant(doc)
)
);
}
if (_body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames)
{
bodyStmt = AddFrame(LocalContext, FuncCodeExpr, bodyStmt);
locals.Add(FunctionStackVariable);
}
bodyStmt = WrapScopeStatements(
Ast.Block(
Ast.Block(init),
statements.Count == 0 ?
EmptyBlock :
Ast.Block(new ReadOnlyCollection <MSAst.Expression>(statements)),
modStmt,
bodyStmt,
LocalContext
),
_body.CanThrow
);
var lambda = AstUtils.LightLambda <Func <CodeContext, CodeContext> >(
typeof(CodeContext),
Ast.Block(
locals,
bodyStmt
),
Name + "$" + Interlocked.Increment(ref _classId),
new[] { _parentContextParam }
);
return(lambda);
}
public ReadOnlyCollection <IWebElement> DownloadTimbratureCurrentMonth(string user, string pwd, DateTime targetDate, TimbratureBuilder builder, System.ComponentModel.BackgroundWorker worker)
{
#pragma warning disable CS0618 // Type or member is obsolete
wait.Until(ExpectedConditions.ElementExists(By.Name("m_cUserName")));
wait.Until(ExpectedConditions.ElementExists(By.Name("m_cPassword")));
wait.Until(ExpectedConditions.ElementExists(By.CssSelector("input[class='buttonlogin Accedi_ctrl']")));
try
{
worker.ReportProgress(5);
// LOGIN
driver.FindElement(By.Name("m_cUserName")).SendKeys(user);
driver.FindElement(By.Name("m_cPassword")).SendKeys(pwd);
driver.FindElement(By.CssSelector("input[class='buttonlogin Accedi_ctrl']")).Click();
// TIMBRATURE
wait.Until(ExpectedConditions.ElementExists(By.CssSelector("td[class='grid_title grid_cell_title']")));
worker.ReportProgress(40);
String tableId = driver.FindElement(By.ClassName("hfpr_wcartellino2c_container")).GetAttribute("id");
Regex rx = new Regex(@"^(.*?)_container", RegexOptions.Compiled | RegexOptions.IgnoreCase);
MatchCollection matches = rx.Matches(tableId);
if (matches.Count > 0)
{
ReadOnlyCollectionBuilder <IWebElement> collection = new ReadOnlyCollectionBuilder <IWebElement>(5);
String randomId = matches[0].Groups[1].Value;
DateTime currentPageMonth = DateTime.Now;
DateTime firstDayNumber = Utils.getFirstWorkingDayOfWeekAsDate(targetDate);//todo check if first day is previous month
DateTime currDay = firstDayNumber;
bool bNewMonth = false;
for (int i = 0; i < 5; ++i)
{
currDay = firstDayNumber.AddDays(i);
bNewMonth = currDay.Month != currentPageMonth.Month;
if (!bNewMonth)
{
IWebElement elem = driver.FindElement(By.Id(randomId + "_Grid1_row" + (currDay.Day - 1)));
builder.addDate(elem, currDay.DayOfWeek);
collection.Add(elem);
worker.ReportProgress(52 + i * 12);
}
else
{
IWebElement currMonth = new SelectElement(driver.FindElement(By.ClassName("TxtMese_ctrl"))).SelectedOption;
if ((currDay.Month < currentPageMonth.Month && currDay.Year == currentPageMonth.Year) || currDay.Year < currentPageMonth.Year)
{
driver.FindElement(By.ClassName("BtnMesePrev_ctrl")).Click();
currentPageMonth = currentPageMonth.AddMonths(-1);
}
else
{
driver.FindElement(By.ClassName("BtnMeseNext_ctrl")).Click();
currentPageMonth = currentPageMonth.AddMonths(1);
}
wait.Until(ExpectedConditions.ElementSelectionStateToBe(currMonth, false));
wait.Until(ExpectedConditions.ElementExists(By.CssSelector("td[class='grid_title grid_cell_title']")));
i--;//redo current loop, we changed month
}
}
return(collection.ToReadOnlyCollection());
}
else
{
//ReadOnlyCollection<IWebElement> selected = driver.FindElements(By.CssSelector("tr[class='grid_row grid_rowselected']")); // WTF ZUCCHETTI
ReadOnlyCollection <IWebElement> selected = driver.FindElements(By.XPath("//*[@class='grid_row grid_rowselected']")); // WTF ZUCCHETTI
ReadOnlyCollection <IWebElement> selectedOdd = driver.FindElements(By.CssSelector("tr[class='grid_rowodd grid_rowselected']")); // WTF ZUCCHETTI
ReadOnlyCollection <IWebElement> pairRowsRO = driver.FindElements(By.XPath("//*[@class='grid_row']")); // REALLYYY. ZUCCHETTI PLZ
ReadOnlyCollection <IWebElement> oddRowsRO = driver.FindElements(By.XPath("//*[@class='grid_rowodd']")); // REALLYYY. ZUCCHETTI PLZ
return(new ReadOnlyCollectionBuilder <IWebElement>(pairRowsRO.Concat(oddRowsRO)
.Concat(selectedOdd)
.Concat(selected))
.ToReadOnlyCollection());
}
}
catch
{
}
return(new ReadOnlyCollectionBuilder <IWebElement>().ToReadOnlyCollection());
#pragma warning restore CS0618 // Type or member is obsolete
}
internal void CreateVariables(ReadOnlyCollectionBuilder<ParameterExpression> locals, List<Expression> init)
{
if (_scopeVars != null)
foreach (var local in _scopeVars)
{
Debug.Assert(local.Kind == VariableKind.Local || local.Kind == VariableKind.Parameter);
ClosureExpression closure = GetVariableExpression(local) as ClosureExpression;
if (closure != null)
{
init.Add(closure.Create());
locals.Add((ParameterExpression)closure.ClosureCell);
}
else if (local.Kind == VariableKind.Local)
{
locals.Add((ParameterExpression)GetVariableExpression(local));
if (local.ReadBeforeInitialized)
{
init.Add(
AssignValue(
GetVariableExpression(local),
Expression.Field(null, typeof(Uninitialized).GetField("Value"))
)
);
}
}
}
}
internal MSAst.Expression ReduceWorker()
{
var retStmt = _body as ReturnStatement;
if (retStmt != null &&
(_languageFeatures == ModuleOptions.None ||
_languageFeatures == (ModuleOptions.ExecOrEvalCode | ModuleOptions.Interpret) ||
_languageFeatures == (ModuleOptions.ExecOrEvalCode | ModuleOptions.Interpret | ModuleOptions.LightThrow)))
{
// for simple eval's we can construct a simple tree which just
// leaves the value on the stack. Return's can't exist in modules
// so this is always safe.
Debug.Assert(!IsModule);
var ret = (ReturnStatement)_body;
Ast simpleBody;
if ((_languageFeatures & ModuleOptions.LightThrow) != 0)
{
simpleBody = LightExceptions.Rewrite(retStmt.Expression.Reduce());
}
else
{
simpleBody = retStmt.Expression.Reduce();
}
var start = IndexToLocation(ret.Expression.StartIndex);
var end = IndexToLocation(ret.Expression.EndIndex);
return(Ast.Block(
Ast.DebugInfo(
_document,
start.Line,
start.Column,
end.Line,
end.Column
),
AstUtils.Convert(simpleBody, typeof(object))
));
}
ReadOnlyCollectionBuilder <MSAst.Expression> block = new ReadOnlyCollectionBuilder <MSAst.Expression>();
AddInitialiation(block);
if (IsModule)
{
block.Add(AssignValue(GetVariableExpression(DocVariable), Ast.Constant(GetDocumentation(_body))));
}
if (!(_body is SuiteStatement) && _body.CanThrow)
{
// we only initialize line numbers in suite statements but if we don't generate a SuiteStatement
// at the top level we can miss some line number updates.
block.Add(UpdateLineNumber(_body.Start.Line));
}
block.Add(_body);
MSAst.Expression body = Ast.Block(block.ToReadOnlyCollection());
body = WrapScopeStatements(body, Body.CanThrow); // new ComboActionRewriter().VisitNode(Transform(ag))
body = AddModulePublishing(body);
body = AddProfiling(body);
if ((((PythonCompilerOptions)_compilerContext.Options).Module & ModuleOptions.LightThrow) != 0)
{
body = LightExceptions.Rewrite(body);
}
body = Ast.Label(FunctionDefinition._returnLabel, AstUtils.Convert(body, typeof(object)));
if (body.Type == typeof(void))
{
body = Ast.Block(body, Ast.Constant(null));
}
return(body);
}
private static Expression[] GetConvertedArgs(params Expression[] args) {
ReadOnlyCollectionBuilder<Expression> paramArgs = new ReadOnlyCollectionBuilder<Expression>(args.Length);
for (int i = 0; i < args.Length; i++) {
paramArgs.Add(Expression.Convert(args[i], typeof(object)));
}
return paramArgs.ToArray();
}
internal Expression Reduce()
{
// Visit body
Expression body = Visit(_generator.Body);
Debug.Assert(_returnLabels.Count == 1);
// Add the switch statement to the body
int count = _yields.Count;
var cases = new SwitchCase[count + 1];
for (int i = 0; i < count; i++)
{
cases[i] = Expression.SwitchCase(Expression.Goto(_yields[i].Label), AstUtils.Constant(_yields[i].State));
}
cases[count] = Expression.SwitchCase(Expression.Goto(_returnLabels.Peek()), AstUtils.Constant(Finished));
Type generatorNextOfT = typeof(GeneratorNext <>).MakeGenericType(_generator.Target.Type);
// Create the lambda for the GeneratorNext<T>, hoisting variables
// into a scope outside the lambda
var allVars = new List <ParameterExpression>(_vars);
allVars.AddRange(_temps);
// Collect temps that don't have to be closed over
var innerTemps = new ReadOnlyCollectionBuilder <ParameterExpression>(1 + (_labelTemps?.Count ?? 0));
innerTemps.Add(_gotoRouter);
if (_labelTemps != null)
{
foreach (LabelInfo info in _labelTemps.Values)
{
innerTemps.Add(info.Temp);
}
}
body = Expression.Block(
allVars,
Expression.Lambda(
generatorNextOfT,
Expression.Block(
innerTemps,
Expression.Switch(Expression.Assign(_gotoRouter, _state), cases),
body,
Expression.Assign(_state, AstUtils.Constant(Finished)),
Expression.Label(_returnLabels.Peek())
),
_generator.Name,
new ParameterExpression[] { _state, _current }
)
);
// Enumerable factory takes Func<GeneratorNext<T>> instead of GeneratorNext<T>
if (_generator.IsEnumerable)
{
body = Expression.Lambda(body);
}
// We can't create a ConstantExpression of _debugCookies array here because we walk the tree
// after constants have already been rewritten. Instead we create a NewArrayExpression node
// which initializes the array with contents from _debugCookies
Expression debugCookiesArray = null;
if (_debugCookies != null)
{
Expression[] debugCookies = new Expression[_debugCookies.Count];
for (int i = 0; i < _debugCookies.Count; i++)
{
debugCookies[i] = AstUtils.Constant(_debugCookies[i]);
}
debugCookiesArray = Expression.NewArrayInit(
typeof(int),
debugCookies);
}
// Generate a call to ScriptingRuntimeHelpers.MakeGenerator<T>(args)
return(Expression.Call(
typeof(ScriptingRuntimeHelpers),
"MakeGenerator",
new[] { _generator.Target.Type },
(debugCookiesArray != null)
? new[] { body, debugCookiesArray }
: new[] { body }
));
}
private LightLambdaExpression CreateFunctionLambda()
{
bool needsWrapperMethod = _parameters.Length > TotemCallTargets.MAX_ARGS;
Delegate originalDelegate;
Type delegateType = GetDelegateType(_parameters, needsWrapperMethod, out originalDelegate);
ReadOnlyCollectionBuilder<ParameterExpression> locals = new ReadOnlyCollectionBuilder<ParameterExpression>();
ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);
List<Expression> init = new List<Expression>();
foreach (var param in _parameters)
{
ITotemVariableExpression toVar = GetVariableExpression(param.TotemVariable) as ITotemVariableExpression;
if (toVar != null)
{
var varInit = toVar.Create();
if (varInit != null)
init.Add(varInit);
}
}
// Transform the parameters.
init.Add(Expression.ClearDebugInfo(GlobalParent.Document));
locals.Add(TotemAst._globalContext);
init.Add(Expression.Assign(TotemAst._globalContext, new GetGlobalContextExpression(_parentContext)));
if (IsClosure)
{
locals.Add(LocalClosureTuple);
init.Add(
Expression.Assign(
LocalClosureTuple,
Utils.Convert(
_localClosure,
LocalClosureTupleType
)
)
);
}
GlobalParent.PrepareScope(locals, init);
// Create variables and references. Since references refer to
// parameters, do this after parameters have been created.
CreateFunctionVariables(locals, init);
// Initialize parameters - unpack tuples.
// Since tuples unpack into locals, this must be done after locals have been created.
InitializeParameters(init, needsWrapperMethod, parameters);
List<Expression> statements = new List<Expression>();
// Add beginning sequence point
var start = GlobalParent.IndexToLocation(StartIndex);
statements.Add(
GlobalParent.AddDebugInfo(
Utils.Empty(),
new SourceSpan(
new SourceLocation(0, start.Line, start.Column),
new SourceLocation(0, start.Line, Int32.MaxValue)
)
)
);
// For generators, we need to do a check before the first statement for Generator.Throw / Generator.Close.
// The exception traceback needs to come from the generator's method body, and so we must do the check and throw
// from inside the generator.
if (IsGenerator)
{
//Expression s1 = YieldExpr.CreateCheckThrowExpression(SourceSpan.None);
//statements.Add(s1);
throw new NotImplementedException("Generators");
}
if (_body.CanThrow && !(_body is BlockStmt) && _body.StartIndex != -1)
{
statements.Add(
UpdateLineNumber(
GlobalParent.IndexToLocation(_body.StartIndex).Line
)
);
}
statements.Add(Body);
Expression body = Expression.Block(statements);
body = AddProfiling(body);
body = WrapScopeStatements(body, _body.CanThrow);
body = Expression.Block(body, Utils.Empty());
body = AddReturnTarget(body);
Expression bodyStmt = body;
init.Add(bodyStmt);
bodyStmt = Expression.Block(init);
// wrap a scope if needed
bodyStmt = Expression.Block(locals.ToReadOnlyCollection(), bodyStmt);
return Utils.LightLambda(
typeof(object),
delegateType,
AddDefaultReturn(bodyStmt, typeof(object)),
Name + "$" + Interlocked.Increment(ref _lambdaId),
parameters
);
}
public override MSAst.Expression Reduce()
{
if (_names == _star)
{
// from a[.b] import *
return(GlobalParent.AddDebugInfo(
Ast.Call(
AstMethods.ImportStar,
Parent.LocalContext,
AstUtils.Constant(_root.MakeString()),
AstUtils.Constant(GetLevel())
),
Span
));
}
else
{
// from a[.b] import x [as xx], [ y [ as yy] ] [ , ... ]
ReadOnlyCollectionBuilder <MSAst.Expression> statements = new ReadOnlyCollectionBuilder <MSAst.Expression>();
MSAst.ParameterExpression module = Ast.Variable(typeof(object), "module");
// Create initializer of the array of names being passed to ImportWithNames
MSAst.Expression[] names = new MSAst.Expression[_names.Length];
for (int i = 0; i < names.Length; i++)
{
names[i] = AstUtils.Constant(_names[i]);
}
// module = PythonOps.ImportWithNames(<context>, _root, make_array(_names))
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
AssignValue(
module,
LightExceptions.CheckAndThrow(
Expression.Call(
AstMethods.ImportWithNames,
Parent.LocalContext,
AstUtils.Constant(_root.MakeString()),
Ast.NewArrayInit(typeof(string), names),
AstUtils.Constant(GetLevel())
)
)
),
_root.Span
)
);
// now load all the names being imported and assign the variables
for (int i = 0; i < names.Length; i++)
{
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
AssignValue(
Parent.GetVariableExpression(_variables[i]),
Ast.Call(
AstMethods.ImportFrom,
Parent.LocalContext,
module,
names[i]
)
),
Span
)
);
}
statements.Add(AstUtils.Empty());
return(GlobalParent.AddDebugInfo(Ast.Block(new[] { module }, statements.ToArray()), Span));
}
}
internal Ast AddVariables(Ast expression) {
ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
MSAst.ParameterExpression localContext = null;
if (NeedsLocalContext) {
localContext = _compContext;
locals.Add(_compContext);
}
List<MSAst.Expression> body = new List<MSAst.Expression>();
CreateVariables(locals, body);
if (localContext != null) {
var createLocal = CreateLocalContext(_comprehension.Parent.LocalContext);
body.Add(Ast.Assign(_compContext, createLocal));
body.Add(expression);
} else {
body.Add(expression);
}
return Expression.Block(
locals,
body
);
}
/// <summary>
/// Creates the LambdaExpression which implements the body of the function.
///
/// The functions signature is either "object Function(PythonFunction, ...)"
/// where there is one object parameter for each user defined parameter or
/// object Function(PythonFunction, object[]) for functions which take more
/// than PythonCallTargets.MaxArgs arguments.
/// </summary>
private MSAst.LambdaExpression CreateFunctionLambda() {
bool needsWrapperMethod = _parameters.Length > PythonCallTargets.MaxArgs;
Delegate originalDelegate;
Type delegateType = GetDelegateType(_parameters, needsWrapperMethod, out originalDelegate);
MSAst.ParameterExpression localContext = null;
ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
if (NeedsLocalsDictionary || ContainsNestedFreeVariables) {
localContext = LocalCodeContextVariable;
locals.Add(localContext);
}
MSAst.ParameterExpression[] parameters = CreateParameters(needsWrapperMethod, locals);
List<MSAst.Expression> init = new List<MSAst.Expression>();
foreach (var param in _parameters) {
IPythonVariableExpression pyVar = GetVariableExpression(param.PythonVariable) as IPythonVariableExpression;
if (pyVar != null) {
var varInit = pyVar.Create();
if (varInit != null) {
init.Add(varInit);
}
}
}
// Transform the parameters.
init.Add(Ast.ClearDebugInfo(GlobalParent.Document));
locals.Add(PythonAst._globalContext);
init.Add(Ast.Assign(PythonAst._globalContext, Ast.Call(_GetGlobalContext, _parentContext)));
GlobalParent.PrepareScope(locals, init);
// Create variables and references. Since references refer to
// parameters, do this after parameters have been created.
CreateFunctionVariables(locals, init);
// Initialize parameters - unpack tuples.
// Since tuples unpack into locals, this must be done after locals have been created.
InitializeParameters(init, needsWrapperMethod, parameters);
List<MSAst.Expression> statements = new List<MSAst.Expression>();
// add beginning sequence point
statements.Add(GlobalParent.AddDebugInfo(
AstUtils.Empty(),
new SourceSpan(new SourceLocation(0, Start.Line, Start.Column), new SourceLocation(0, Start.Line, Int32.MaxValue))));
// For generators, we need to do a check before the first statement for Generator.Throw() / Generator.Close().
// The exception traceback needs to come from the generator's method body, and so we must do the check and throw
// from inside the generator.
if (IsGenerator) {
MSAst.Expression s1 = YieldExpression.CreateCheckThrowExpression(SourceSpan.None);
statements.Add(s1);
}
MSAst.ParameterExpression extracted = null;
if (!IsGenerator && _canSetSysExcInfo) {
// need to allocate the exception here so we don't share w/ exceptions made & freed
// during the body.
extracted = Ast.Parameter(typeof(Exception), "$ex");
locals.Add(extracted);
}
if (_body.CanThrow && !(_body is SuiteStatement) && _body.Start.IsValid) {
statements.Add(UpdateLineNumber(_body.Start.Line));
}
statements.Add(Body);
MSAst.Expression body = Ast.Block(statements);
// If this function can modify sys.exc_info() (_canSetSysExcInfo), then it must restore the result on finish.
//
// Wrap in
// $temp = PythonOps.SaveCurrentException()
// <body>
// PythonOps.RestoreCurrentException($temp)
// Skip this if we're a generator. For generators, the try finally is handled by the PythonGenerator class
// before it's invoked. This is because the restoration must occur at every place the function returns from
// a yield point. That's different than the finally semantics in a generator.
if (extracted != null) {
MSAst.Expression s = AstUtils.Try(
Ast.Assign(
extracted,
Ast.Call(AstMethods.SaveCurrentException)
),
body
).Finally(
Ast.Call(
AstMethods.RestoreCurrentException, extracted
)
);
body = s;
}
if (_body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames) {
body = AddFrame(LocalContext, Ast.Property(_functionParam, typeof(PythonFunction).GetProperty("__code__")), body);
locals.Add(FunctionStackVariable);
}
body = AddProfiling(body);
body = WrapScopeStatements(body, _body.CanThrow);
body = Ast.Block(body, AstUtils.Empty());
body = AddReturnTarget(body);
MSAst.Expression bodyStmt = body;
if (localContext != null) {
var createLocal = CreateLocalContext(_parentContext);
init.Add(
Ast.Assign(
localContext,
createLocal
)
);
}
init.Add(bodyStmt);
bodyStmt = Ast.Block(init);
// wrap a scope if needed
bodyStmt = Ast.Block(locals.ToReadOnlyCollection(), bodyStmt);
return Ast.Lambda(
delegateType,
AddDefaultReturn(bodyStmt, typeof(object)),
Name + "$" + Interlocked.Increment(ref _lambdaId),
parameters
);
}
private MSAst.ParameterExpression[] CreateParameters(ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals)
{
MSAst.ParameterExpression[] parameters = new[] { _functionParam, _argumentsParam };
foreach (var param in _parameters)
locals.Add(param.ParameterExpression);
return parameters;
}
private MSAst.ParameterExpression[] CreateParameters(bool needsWrapperMethod, ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals) {
MSAst.ParameterExpression[] parameters;
if (needsWrapperMethod) {
parameters = new[] { _functionParam, Ast.Parameter(typeof(object[]), "allArgs") };
foreach (var param in _parameters) {
locals.Add(param.ParameterExpression);
}
} else {
parameters = new MSAst.ParameterExpression[_parameters.Length + 1];
for (int i = 1; i < parameters.Length; i++) {
parameters[i] = _parameters[i - 1].ParameterExpression;
}
parameters[0] = _functionParam;
}
return parameters;
}
public override void PrepareScope(PythonAst ast, ReadOnlyCollectionBuilder <MSAst.ParameterExpression> locals, List <MSAst.Expression> init)
{
locals.Add(PythonAst._globalArray);
init.Add(Ast.Assign(PythonAst._globalArray, ast._arrayExpression));
}
public override MSAst.Expression Reduce() {
if (_names == _star) {
// from a[.b] import *
return GlobalParent.AddDebugInfo(
Ast.Call(
AstMethods.ImportStar,
Parent.LocalContext,
AstUtils.Constant(_root.MakeString()),
AstUtils.Constant(GetLevel())
),
Span
);
} else {
// from a[.b] import x [as xx], [ y [ as yy] ] [ , ... ]
ReadOnlyCollectionBuilder<MSAst.Expression> statements = new ReadOnlyCollectionBuilder<MSAst.Expression>();
MSAst.ParameterExpression module = Ast.Variable(typeof(object), "module");
// Create initializer of the array of names being passed to ImportWithNames
MSAst.Expression[] names = new MSAst.Expression[_names.Length];
for (int i = 0; i < names.Length; i++) {
names[i] = AstUtils.Constant(_names[i]);
}
// module = PythonOps.ImportWithNames(<context>, _root, make_array(_names))
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
AssignValue(
module,
LightExceptions.CheckAndThrow(
Expression.Call(
AstMethods.ImportWithNames,
Parent.LocalContext,
AstUtils.Constant(_root.MakeString()),
Ast.NewArrayInit(typeof(string), names),
AstUtils.Constant(GetLevel())
)
)
),
_root.Span
)
);
// now load all the names being imported and assign the variables
for (int i = 0; i < names.Length; i++) {
statements.Add(
GlobalParent.AddDebugInfoAndVoid(
AssignValue(
Parent.GetVariableExpression(_variables[i]),
Ast.Call(
AstMethods.ImportFrom,
Parent.LocalContext,
module,
names[i]
)
),
Span
)
);
}
statements.Add(AstUtils.Empty());
return GlobalParent.AddDebugInfo(Ast.Block(new[] { module }, statements.ToArray()), Span);
}
}
internal void CreateVariables(ReadOnlyCollectionBuilder<MSAst.ParameterExpression> locals, List<MSAst.Expression> init) {
if (Variables != null) {
foreach (PythonVariable variable in Variables.Values) {
if(variable.Kind != VariableKind.Global) {
ClosureExpression closure = GetVariableExpression(variable) as ClosureExpression;
if (closure != null) {
init.Add(closure.Create());
locals.Add((MSAst.ParameterExpression)closure.ClosureCell);
} else if (variable.Kind == VariableKind.Local) {
locals.Add((MSAst.ParameterExpression)GetVariableExpression(variable));
if (variable.ReadBeforeInitialized) {
init.Add(
AssignValue(
GetVariableExpression(variable),
MSAst.Expression.Field(null, typeof(Uninitialized).GetField("Instance"))
)
);
}
}
}
}
}
if (IsClosure) {
Type tupleType = Parent.GetClosureTupleType();
Debug.Assert(tupleType != null);
init.Add(
MSAst.Expression.Assign(
LocalParentTuple,
MSAst.Expression.Convert(
GetParentClosureTuple(),
tupleType
)
)
);
locals.Add(LocalParentTuple);
}
}
internal MSAst.Expression ReduceWorker() {
ReadOnlyCollectionBuilder<MSAst.Expression> block = new ReadOnlyCollectionBuilder<MSAst.Expression>();
if (_body is ReturnStatement && (_languageFeatures == ModuleOptions.None || _languageFeatures == ModuleOptions.Interpret)) {
// for simple eval's we can construct a simple tree which just
// leaves the value on the stack. Return's can't exist in modules
// so this is always safe.
Debug.Assert(!_isModule);
return AstUtils.Convert(((ReturnStatement)_body).Expression.Reduce(), typeof(object));
}
AddInitialiation(block);
if (_isModule) {
block.Add(AssignValue(GetVariableExpression(_docVariable), Ast.Constant(GetDocumentation(_body))));
}
block.Add(_body);
MSAst.Expression body = Ast.Block(block.ToReadOnlyCollection());
body = WrapScopeStatements(body, Body.CanThrow); // new ComboActionRewriter().VisitNode(Transform(ag))
body = AddModulePublishing(body);
body = AddProfiling(body);
body = Ast.Label(FunctionDefinition._returnLabel, AstUtils.Convert(body, typeof(object)));
if (body.Type == typeof(void)) {
body = Ast.Block(body, Ast.Constant(null));
}
return body;
}
public MSA.Expression/*!*/ CreateScope(MSA.Expression/*!*/ scopeVariable, MSA.Expression/*!*/ scopeInitializer, MSA.Expression/*!*/ body) {
// #locals variable already assigned (in MakeClosureDefinition).
// We need to initialize #closureN variables.
if (_closures != null) {
if (_closures.Count == 1) {
return Ast.Block(_hiddenVariables, Ast.Block(
Ast.Assign(
_closures[0],
AstUtils.Convert(Methods.GetParentLocals.OpCall(Ast.Assign(scopeVariable, scopeInitializer)), _closures[0].Type)
),
body
));
} else {
var result = new ReadOnlyCollectionBuilder<MSA.Expression>();
MSA.Expression tempScope = DefineHiddenVariable("#s", typeof(RubyScope));
result.Add(Ast.Assign(scopeVariable, scopeInitializer));
for (int i = 0; i < _closures.Count; i++) {
result.Add(
Ast.Assign(
_closures[i],
AstUtils.Convert(
Methods.GetLocals.OpCall(Ast.Assign(tempScope, Methods.GetParentScope.OpCall(i == 0 ? scopeVariable : tempScope))),
_closures[i].Type
)
)
);
}
result.Add(body);
return Ast.Block(_hiddenVariables, result);
}
} else {
return Ast.Block(_hiddenVariables, Ast.Block(Ast.Assign(scopeVariable, scopeInitializer), body));
}
}
internal ReadOnlyCollection<MSAst.Expression> Transform(Statement/*!*/[]/*!*/ from) {
Debug.Assert(from != null);
var to = new ReadOnlyCollectionBuilder<MSAst.Expression>(from.Length + 1);
SourceLocation start = SourceLocation.Invalid;
for (int i = 0; i < from.Length; i++) {
Debug.Assert(from[i] != null);
to.Add(TransformMaybeSingleLineSuite(from[i], start));
start = from[i].Start;
}
to.Add(AstUtils.Empty());
return to.ToReadOnlyCollection();
}
internal MSAst.Expression ReduceWorker() {
var retStmt = _body as ReturnStatement;
if (retStmt != null &&
(_languageFeatures == ModuleOptions.None ||
_languageFeatures == (ModuleOptions.ExecOrEvalCode | ModuleOptions.Interpret) ||
_languageFeatures == (ModuleOptions.ExecOrEvalCode | ModuleOptions.Interpret | ModuleOptions.LightThrow))) {
// for simple eval's we can construct a simple tree which just
// leaves the value on the stack. Return's can't exist in modules
// so this is always safe.
Debug.Assert(!_isModule);
var ret = (ReturnStatement)_body;
Ast simpleBody;
if ((_languageFeatures & ModuleOptions.LightThrow) != 0) {
simpleBody = LightExceptions.Rewrite(retStmt.Expression.Reduce());
} else {
simpleBody = retStmt.Expression.Reduce();
}
var start = IndexToLocation(ret.Expression.StartIndex);
var end = IndexToLocation(ret.Expression.EndIndex);
return Ast.Block(
Ast.DebugInfo(
_document,
start.Line,
start.Column,
end.Line,
end.Column
),
AstUtils.Convert(simpleBody, typeof(object))
);
}
ReadOnlyCollectionBuilder<MSAst.Expression> block = new ReadOnlyCollectionBuilder<MSAst.Expression>();
AddInitialiation(block);
if (_isModule) {
block.Add(AssignValue(GetVariableExpression(_docVariable), Ast.Constant(GetDocumentation(_body))));
}
if (!(_body is SuiteStatement) && _body.CanThrow) {
// we only initialize line numbers in suite statements but if we don't generate a SuiteStatement
// at the top level we can miss some line number updates.
block.Add(UpdateLineNumber(_body.Start.Line));
}
block.Add(_body);
MSAst.Expression body = Ast.Block(block.ToReadOnlyCollection());
body = WrapScopeStatements(body, Body.CanThrow); // new ComboActionRewriter().VisitNode(Transform(ag))
body = AddModulePublishing(body);
body = AddProfiling(body);
if ((((PythonCompilerOptions)_compilerContext.Options).Module & ModuleOptions.LightThrow) != 0) {
body = LightExceptions.Rewrite(body);
}
body = Ast.Label(FunctionDefinition._returnLabel, AstUtils.Convert(body, typeof(object)));
if (body.Type == typeof(void)) {
body = Ast.Block(body, Ast.Constant(null));
}
return body;
}
internal override MSAst.Expression TransformSet(SourceSpan span, MSAst.Expression right, PythonOperationKind op)
{
// if we just have a simple named multi-assignment (e.g. a, b = 1,2)
// then go ahead and step over the entire statement at once. If we have a
// more complex statement (e.g. a.b, c.d = 1, 2) then we'll step over the
// sets individually as they could be property sets the user wants to step
// into. TODO: Enable stepping of the right hand side?
bool emitIndividualSets = false;
foreach (Expression e in _items)
{
if (IsComplexAssignment(e))
{
emitIndividualSets = true;
break;
}
}
SourceSpan rightSpan = SourceSpan.None;
SourceSpan leftSpan =
(Span.Start.IsValid && span.IsValid) ?
new SourceSpan(Span.Start, span.End) :
SourceSpan.None;
SourceSpan totalSpan = SourceSpan.None;
if (emitIndividualSets)
{
rightSpan = span;
leftSpan = SourceSpan.None;
totalSpan = (Span.Start.IsValid && span.IsValid) ?
new SourceSpan(Span.Start, span.End) :
SourceSpan.None;
}
// 1. Evaluate the expression and assign the value to the temp.
MSAst.ParameterExpression right_temp = Ast.Variable(typeof(object), "unpacking");
// 2. Add the assignment "right_temp = right" into the suite/block
MSAst.Expression assignStmt1 = MakeAssignment(right_temp, right);
// 3. Call GetEnumeratorValues on the right side (stored in temp)
MSAst.Expression enumeratorValues = Expression.Convert(LightExceptions.CheckAndThrow(
Expression.Call(
emitIndividualSets ?
AstMethods.GetEnumeratorValues :
AstMethods.GetEnumeratorValuesNoComplexSets, // method
// arguments
Parent.LocalContext,
right_temp,
AstUtils.Constant(_items.Length)
)
), typeof(object[]));
// 4. Create temporary variable for the array
MSAst.ParameterExpression array_temp = Ast.Variable(typeof(object[]), "array");
// 5. Assign the value of the method call (mce) into the array temp
// And add the assignment "array_temp = Ops.GetEnumeratorValues(...)" into the block
MSAst.Expression assignStmt2 = MakeAssignment(
array_temp,
enumeratorValues,
rightSpan
);
ReadOnlyCollectionBuilder <MSAst.Expression> sets = new ReadOnlyCollectionBuilder <MSAst.Expression>(_items.Length + 1);
for (int i = 0; i < _items.Length; i++)
{
// target = array_temp[i]
Expression target = _items[i];
if (target == null)
{
continue;
}
// 6. array_temp[i]
MSAst.Expression element = Ast.ArrayAccess(
array_temp, // array expression
AstUtils.Constant(i) // index
);
// 7. target = array_temp[i], and add the transformed assignment into the list of sets
MSAst.Expression set = target.TransformSet(
emitIndividualSets ? // span
target.Span :
SourceSpan.None,
element,
PythonOperationKind.None
);
sets.Add(set);
}
// 9. add the sets as their own block so they can be marked as a single span, if necessary.
sets.Add(AstUtils.Empty());
MSAst.Expression itemSet = GlobalParent.AddDebugInfo(Ast.Block(sets.ToReadOnlyCollection()), leftSpan);
// 10. Return the suite statement (block)
return(GlobalParent.AddDebugInfo(Ast.Block(new[] { array_temp, right_temp }, assignStmt1, assignStmt2, itemSet, AstUtils.Empty()), totalSpan));
}
private Expression VisitAssign(BinaryExpression node)
{
int yields = _yields.Count;
Expression left = Visit(node.Left);
Expression right = Visit(node.Right);
if (left == node.Left && right == node.Right)
{
return(node);
}
if (yields == _yields.Count)
{
return(Expression.Assign(left, right));
}
var block = new ReadOnlyCollectionBuilder <Expression>();
if (_generator.RewriteAssignments)
{
// We need to make sure that LHS is evaluated before RHS. For example,
//
// {expr0}[{expr1},..,{exprN}] = {rhs}
// ->
// { l0 = {expr0}; l1 = {expr1}; ..; lN = {exprN}; r = {rhs}; l0[l1,..,lN] = r }
//
if (left == node.Left)
{
switch (left.NodeType)
{
case ExpressionType.MemberAccess:
var member = (MemberExpression)node.Left;
if (member.Expression != null)
{
left = member.Update(ToTemp(block, member.Expression));
}
break;
case ExpressionType.Index:
var index = (IndexExpression)node.Left;
left = index.Update((index.Object != null ? ToTemp(block, index.Object) : null), ToTemp(block, index.Arguments));
break;
case ExpressionType.Parameter:
// no action needed
break;
default:
// Extension should've been reduced by Visit above,
// and returned a different node
throw Assert.Unreachable;
}
}
else
{
// Get the last expression of the rewritten left side
var leftBlock = (BlockExpression)left;
block.AddRange(leftBlock.Expressions);
block.RemoveAt(block.Count - 1);
left = leftBlock.Expressions[leftBlock.Expressions.Count - 1];
}
}
if (right != node.Right)
{
right = ToTemp(block, right);
}
block.Add(Expression.Assign(left, right));
return(Expression.Block(block));
}
private void AddInitialiation(ReadOnlyCollectionBuilder<MSAst.Expression> block) {
if (_isModule) {
block.Add(AssignValue(GetVariableExpression(_fileVariable), Ast.Constant(ModuleFileName)));
block.Add(AssignValue(GetVariableExpression(_nameVariable), Ast.Constant(ModuleName)));
}
if (_languageFeatures != ModuleOptions.None || _isModule) {
block.Add(
Ast.Call(
AstMethods.ModuleStarted,
LocalContext,
AstUtils.Constant(_languageFeatures)
)
);
}
}
internal override MSAst.Expression TransformSet(SourceSpan span, MSAst.Expression right, PythonOperationKind op) {
// if we just have a simple named multi-assignment (e.g. a, b = 1,2)
// then go ahead and step over the entire statement at once. If we have a
// more complex statement (e.g. a.b, c.d = 1, 2) then we'll step over the
// sets individually as they could be property sets the user wants to step
// into. TODO: Enable stepping of the right hand side?
bool emitIndividualSets = false;
foreach (Expression e in _items) {
if (IsComplexAssignment(e)) {
emitIndividualSets = true;
break;
}
}
SourceSpan rightSpan = SourceSpan.None;
SourceSpan leftSpan =
(Span.Start.IsValid && span.IsValid) ?
new SourceSpan(Span.Start, span.End) :
SourceSpan.None;
SourceSpan totalSpan = SourceSpan.None;
if (emitIndividualSets) {
rightSpan = span;
leftSpan = SourceSpan.None;
totalSpan = (Span.Start.IsValid && span.IsValid) ?
new SourceSpan(Span.Start, span.End) :
SourceSpan.None;
}
// 1. Evaluate the expression and assign the value to the temp.
MSAst.ParameterExpression right_temp = Ast.Variable(typeof(object), "unpacking");
// 2. Add the assignment "right_temp = right" into the suite/block
MSAst.Expression assignStmt1 = MakeAssignment(right_temp, right);
// 3. Call GetEnumeratorValues on the right side (stored in temp)
MSAst.Expression enumeratorValues = Expression.Convert(LightExceptions.CheckAndThrow(
Expression.Call(
emitIndividualSets ?
AstMethods.GetEnumeratorValues :
AstMethods.GetEnumeratorValuesNoComplexSets, // method
// arguments
Parent.LocalContext,
right_temp,
AstUtils.Constant(_items.Length)
)
), typeof(object[]));
// 4. Create temporary variable for the array
MSAst.ParameterExpression array_temp = Ast.Variable(typeof(object[]), "array");
// 5. Assign the value of the method call (mce) into the array temp
// And add the assignment "array_temp = Ops.GetEnumeratorValues(...)" into the block
MSAst.Expression assignStmt2 = MakeAssignment(
array_temp,
enumeratorValues,
rightSpan
);
ReadOnlyCollectionBuilder<MSAst.Expression> sets = new ReadOnlyCollectionBuilder<MSAst.Expression>(_items.Length + 1);
for (int i = 0; i < _items.Length; i++) {
// target = array_temp[i]
Expression target = _items[i];
if (target == null) {
continue;
}
// 6. array_temp[i]
MSAst.Expression element = Ast.ArrayAccess(
array_temp, // array expression
AstUtils.Constant(i) // index
);
// 7. target = array_temp[i], and add the transformed assignment into the list of sets
MSAst.Expression set = target.TransformSet(
emitIndividualSets ? // span
target.Span :
SourceSpan.None,
element,
PythonOperationKind.None
);
sets.Add(set);
}
// 9. add the sets as their own block so they can be marked as a single span, if necessary.
sets.Add(AstUtils.Empty());
MSAst.Expression itemSet = GlobalParent.AddDebugInfo(Ast.Block(sets.ToReadOnlyCollection()), leftSpan);
// 10. Return the suite statement (block)
return GlobalParent.AddDebugInfo(Ast.Block(new[] { array_temp, right_temp }, assignStmt1, assignStmt2, itemSet, AstUtils.Empty()), totalSpan);
}
private MSAst.Expression ReduceWorker(bool optimizeDynamicConvert)
{
MSAst.Expression result;
if (_tests.Length > 100)
{
// generate:
// if(x) {
// body
// goto end
// } else {
// }
// elseBody
// end:
//
// to avoid deeply recursive trees which can stack overflow.
var builder = new ReadOnlyCollectionBuilder <MSAst.Expression>();
var label = Ast.Label();
for (int i = 0; i < _tests.Length; i++)
{
IfStatementTest ist = _tests[i];
builder.Add(
Ast.Condition(
optimizeDynamicConvert ?
TransformAndDynamicConvert(ist.Test, typeof(bool)) :
GlobalParent.Convert(typeof(bool), Microsoft.Scripting.Actions.ConversionResultKind.ExplicitCast, ist.Test),
Ast.Block(
TransformMaybeSingleLineSuite(ist.Body, ist.Test.Start),
Ast.Goto(label)
),
AstUtils.Empty()
)
);
}
if (_else != null)
{
builder.Add(_else);
}
builder.Add(Ast.Label(label));
result = Ast.Block(builder);
}
else
{
// Now build from the inside out
if (_else != null)
{
result = _else;
}
else
{
result = AstUtils.Empty();
}
int i = _tests.Length;
while (i-- > 0)
{
IfStatementTest ist = _tests[i];
result = GlobalParent.AddDebugInfoAndVoid(
Ast.Condition(
optimizeDynamicConvert ?
TransformAndDynamicConvert(ist.Test, typeof(bool)) :
GlobalParent.Convert(typeof(bool), Microsoft.Scripting.Actions.ConversionResultKind.ExplicitCast, ist.Test),
TransformMaybeSingleLineSuite(ist.Body, ist.Test.Start),
result
),
new SourceSpan(ist.Start, ist.Header)
);
}
}
return(result);
}
private Microsoft.Scripting.Ast.LightExpression<Func<CodeContext, CodeContext>> MakeClassBody() {
// we always need to create a nested context for class defs
var init = new List<MSAst.Expression>();
var locals = new ReadOnlyCollectionBuilder<MSAst.ParameterExpression>();
locals.Add(LocalCodeContextVariable);
locals.Add(PythonAst._globalContext);
init.Add(Ast.Assign(PythonAst._globalContext, new GetGlobalContextExpression(_parentContextParam)));
GlobalParent.PrepareScope(locals, init);
CreateVariables(locals, init);
var createLocal = CreateLocalContext(_parentContextParam);
init.Add(Ast.Assign(LocalCodeContextVariable, createLocal));
List<MSAst.Expression> statements = new List<MSAst.Expression>();
// Create the body
MSAst.Expression bodyStmt = _body;
// __module__ = __name__
MSAst.Expression modStmt = AssignValue(GetVariableExpression(_modVariable), GetVariableExpression(_modNameVariable));
string doc = GetDocumentation(_body);
if (doc != null) {
statements.Add(
AssignValue(
GetVariableExpression(_docVariable),
AstUtils.Constant(doc)
)
);
}
if (_body.CanThrow && GlobalParent.PyContext.PythonOptions.Frames) {
bodyStmt = AddFrame(LocalContext, FuncCodeExpr, bodyStmt);
locals.Add(FunctionStackVariable);
}
bodyStmt = WrapScopeStatements(
Ast.Block(
Ast.Block(init),
statements.Count == 0 ?
EmptyBlock :
Ast.Block(new ReadOnlyCollection<MSAst.Expression>(statements)),
modStmt,
bodyStmt,
LocalContext
),
_body.CanThrow
);
var lambda = AstUtils.LightLambda<Func<CodeContext, CodeContext>>(
typeof(CodeContext),
Ast.Block(
locals,
bodyStmt
),
Name + "$" + Interlocked.Increment(ref _classId),
new[] { _parentContextParam }
);
return lambda;
}
public void TestReadOnlyCollectionBuilder()
{
int cnt = 0;
// Empty
ReadOnlyCollectionBuilder <int> a = new ReadOnlyCollectionBuilder <int>();
AreEqual(0, a.Count);
AreEqual(0, a.Capacity);
AreEqual(a.ToReadOnlyCollection().Count, 0);
AreEqual(a.ToReadOnlyCollection().Count, 0);
// Simple case
a.Add(5);
AreEqual(1, a.Count);
AreEqual(4, a.Capacity);
AreEqual(a.ToReadOnlyCollection()[0], 5);
AreEqual(a.ToReadOnlyCollection().Count, 0); // Will reset
a = new ReadOnlyCollectionBuilder <int>(0);
AreEqual(0, a.Count);
AssertError <ArgumentException>(() => a = new ReadOnlyCollectionBuilder <int>(-1));
a = new ReadOnlyCollectionBuilder <int>(5);
for (int i = 1; i <= 10; i++)
{
a.Add(i);
}
AreEqual(10, a.Capacity);
System.Collections.ObjectModel.ReadOnlyCollection <int> readonlyCollection = a.ToReadOnlyCollection();
AreEqual(0, a.Capacity);
AreEqual(readonlyCollection.Count, 10);
ReadOnlyCollectionBuilder <int> b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
b.Add(11);
AreEqual(b.Count, 11);
AssertError <ArgumentException>(() => a = new ReadOnlyCollectionBuilder <int>(null));
// Capacity tests
b.Capacity = 11;
AssertError <ArgumentException>(() => b.Capacity = 10);
b.Capacity = 50;
AreEqual(b.Count, 11);
AreEqual(b.Capacity, 50);
// IndexOf cases
AreEqual(b.IndexOf(5), 4);
AreEqual(b[4], 5);
a = new ReadOnlyCollectionBuilder <int>();
AreEqual(a.IndexOf(5), -1);
// Insert cases
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
AssertError <ArgumentException>(() => b.Insert(11, 11));
b.Insert(2, 24);
AreEqual(b.Count, 11);
AreEqual(b[1], 2);
AreEqual(b[2], 24);
AreEqual(b[3], 3);
b.Insert(11, 1234);
AssertError <ArgumentException>(() => b.Insert(-1, 55));
AreEqual(b[11], 1234);
AreEqual(b.ToReadOnlyCollection().Count, 12);
// Remove
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
AreEqual(b.Remove(2), true);
AreEqual(b[0], 1);
AreEqual(b[1], 3);
AreEqual(b[2], 4);
AreEqual(b.Remove(2), false);
// RemoveAt
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
b.RemoveAt(2);
AreEqual(b[1], 2);
AreEqual(b[2], 4);
AreEqual(b[3], 5);
AssertError <ArgumentException>(() => b.RemoveAt(-5));
AssertError <ArgumentException>(() => b.RemoveAt(9));
// Clear
b.Clear();
AreEqual(b.Count, 0);
AreEqual(b.ToReadOnlyCollection().Count, 0);
b = new ReadOnlyCollectionBuilder <int>();
b.Clear();
AreEqual(b.Count, 0);
// Contains
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
AreEqual(b.Contains(5), true);
AreEqual(b.Contains(-3), false);
ReadOnlyCollectionBuilder <object> c = new ReadOnlyCollectionBuilder <object>();
c.Add("HI");
AreEqual(c.Contains("HI"), true);
AreEqual(c.Contains(null), false);
c.Add(null);
AreEqual(c.Contains(null), true);
// CopyTo
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
int[] ary = new int[10];
b.CopyTo(ary, 0);
AreEqual(ary[0], 1);
AreEqual(ary[9], 10);
// Reverse
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
b.Reverse();
// 1..10
cnt = 10;
for (int i = 0; i < 10; i++)
{
AreEqual(b[i], cnt--);
}
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
AssertError <ArgumentException>(() => b.Reverse(-1, 5));
AssertError <ArgumentException>(() => b.Reverse(5, -1));
b.Reverse(3, 3);
// 1,2,3,4,5,6,7,8,9.10
// 1,2,3,6,5,4,7,8,9,10
AreEqual(b[1], 2);
AreEqual(b[2], 3);
AreEqual(b[3], 6);
AreEqual(b[4], 5);
AreEqual(b[5], 4);
AreEqual(b[6], 7);
// ToArray
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
int[] intAry = b.ToArray();
AreEqual(intAry[0], 1);
AreEqual(intAry[9], 10);
b = new ReadOnlyCollectionBuilder <int>();
intAry = b.ToArray();
AreEqual(intAry.Length, 0);
// IEnumerable cases
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
cnt = 0;
foreach (int i in b)
{
cnt++;
}
AreEqual(cnt, 10);
b = new ReadOnlyCollectionBuilder <int>();
cnt = 0;
foreach (int i in b)
{
cnt++;
}
AreEqual(cnt, 0);
// Error case
AssertError <InvalidOperationException>(() => ChangeWhileEnumeratingAdd());
AssertError <InvalidOperationException>(() => ChangeWhileEnumeratingRemove());
// IList members
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
System.Collections.IList lst = b;
// IsReadOnly
AreEqual(lst.IsReadOnly, false);
// Add
AreEqual(lst.Add(11), 10);
AreEqual(lst.Count, 11);
AssertError <ArgumentException>(() => lst.Add("MOM"));
AssertError <ArgumentException>(() => lst.Add(null));
c = new ReadOnlyCollectionBuilder <object>();
c.Add("HI");
c.Add(null);
lst = c;
lst.Add(null);
AreEqual(lst.Count, 3);
// Contains
lst = b;
AreEqual(lst.Contains(5), true);
AreEqual(lst.Contains(null), false);
lst = c;
AreEqual(lst.Contains("HI"), true);
AreEqual(lst.Contains("hi"), false);
AreEqual(lst.Contains(null), true);
// IndexOf
lst = b;
AreEqual(lst.IndexOf(null), -1);
AreEqual(lst.IndexOf(1234), -1);
AreEqual(lst.IndexOf(5), 4);
// Insert
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
lst = b;
AssertError <ArgumentException>(() => lst.Insert(11, 11));
lst.Insert(2, 24);
AreEqual(lst.Count, 11);
AreEqual(lst[1], 2);
AreEqual(lst[2], 24);
AreEqual(lst[3], 3);
lst.Insert(11, 1234);
AssertError <ArgumentException>(() => lst.Insert(-1, 55));
AreEqual(lst[11], 1234);
AssertError <ArgumentException>(() => lst.Insert(3, "MOM"));
// IsFixedSize
AreEqual(lst.IsFixedSize, false);
// Remove
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
lst = b;
lst.Remove(2);
AreEqual(lst[0], 1);
AreEqual(lst[1], 3);
AreEqual(lst[2], 4);
lst.Remove(2);
// Indexing
lst[3] = 234;
AreEqual(lst[3], 234);
AssertError <ArgumentException>(() => lst[3] = null);
AssertError <ArgumentException>(() => lst[3] = "HI");
// ICollection<T>
// IsReadOnly
System.Collections.Generic.ICollection <int> col = b;
AreEqual(col.IsReadOnly, false);
// ICollection
b = new ReadOnlyCollectionBuilder <int>(readonlyCollection);
System.Collections.ICollection col2 = b;
AreEqual(col2.IsSynchronized, false);
Assert(col2.SyncRoot != null);
intAry = new int[10];
col2.CopyTo(intAry, 0);
AreEqual(intAry[0], 1);
AreEqual(intAry[9], 10);
string[] str = new string[50];
AssertError <ArrayTypeMismatchException>(() => col2.CopyTo(str, 0));
}