private void WalkTuple(TupleExpression tuple) {
foreach (Expression innerNode in tuple.Items) {
NameExpression name = innerNode as NameExpression;
if (name != null) {
_binder.DefineName(name.Name);
name.Reference = _binder.Reference(name.Name);
} else {
WalkTuple((TupleExpression)innerNode);
}
}
}
public override void PostWalk(TupleExpression node)
{
var tmp = tree.Pop();
var parent = tree.Peek() as AssignmentStatement;
tree.Push(tmp);
if (parent == null || !parent.Left.Contains(node))
{
List<string> statements = new List<string>();
for (int i = 0; i < node.Items.Count; i++)
{
statements.Add(Content());
}
statements.Reverse();
Content("[{0}]", String.Join(", ", statements));
}
CommonPostWalk(node);
}
// TupleExpression
public bool Walk(TupleExpression node)
{
return Process(node);
}
public void PostWalk(TupleExpression node)
{
PostProcess(node);
}
public override bool Walk(TupleExpression node)
{
node.Parent = _binder._currentScope;
return(true);
}
internal Tuple(TupleExpression list, expr_context ctx)
: this() {
_elts = PythonOps.MakeEmptyList(list.Items.Count);
foreach (Compiler.Ast.Expression expr in list.Items)
_elts.Add(Convert(expr, ctx));
_ctx = ctx;
}
public override bool Walk(TupleExpression node)
{
node.Parent = _currentScope;
return base.Walk(node);
}
private static SymbolId EncodeTupleParamName(TupleExpression param)
{
// we encode a tuple parameter so we can extract the compound
// members back out of it's name.
StringBuilder sb = new StringBuilder(tupleArgHeader);
AppendTupleParamNames(sb, param);
return SymbolTable.StringToId(sb.ToString());
}
public virtual void PostWalk(TupleExpression node)
{
}
// TupleExpression
public virtual bool Walk(TupleExpression node)
{
return true;
}
private static Expression MakeTupleOrExpr(List<Expression> l, bool trailingComma, bool expandable)
{
if (l.Count == 1 && !trailingComma) return l[0];
Expression[] exprs = l.ToArray();
TupleExpression te = new TupleExpression(expandable && !trailingComma, exprs);
if (exprs.Length > 0) {
te.SetLoc(exprs[0].ExternalInfo, exprs[0].Start, exprs[exprs.Length - 1].End);
}
return te;
}
public string Visit(PyAst.TupleExpression node) => $"({VisitExpressionsList(node.Items)})";
public override bool Walk(TupleExpression node)
{
return(true);
}
// TupleExpression
public override bool Walk(TupleExpression node)
{
node.Parent = _currentScope;
return(base.Walk(node));
}
public override bool Walk(TupleExpression node)
{
CommonWalk(node);
return true;
}
private static void AppendTupleParamNames(StringBuilder sb, TupleExpression param)
{
for (int i = 0; i < param.Items.Count; i++) {
NameExpression ne = param.Items[i] as NameExpression;
if (ne != null) {
sb.Append('!');
sb.Append(ne.Name.GetString());
} else {
// nested tuple
AppendTupleParamNames(sb, param.Items[i] as TupleExpression);
}
}
}
public SublistParameter(int position, TupleExpression tuple)
: base("." + position, ParameterKind.Normal) {
_tuple = tuple;
}
public override bool Walk(TupleExpression node)
{
node.Parent = _binder._currentScope;
return true;
}
public SublistParameter(int position, TupleExpression tuple)
: base(SymbolTable.StringToId("." + position * 2), ParameterKind.Normal) {
_tuple = tuple;
}
public override bool Walk(TupleExpression node)
{
return true;
}
internal override AstExpression Revert()
{
AstExpression index = null;
if (slice is Index)
index = expr.Revert(((Index)slice).value);
else if (slice is Slice) {
Slice concreteSlice = (Slice)slice;
AstExpression start = null;
if (concreteSlice.lower != null)
start = expr.Revert(concreteSlice.lower);
AstExpression stop = null;
if (concreteSlice.upper != null)
stop = expr.Revert(concreteSlice.upper);
AstExpression step = null;
bool stepProvided = false;
if (concreteSlice.step != null) {
stepProvided = true;
if (concreteSlice.step is Name && ((Name)concreteSlice.step).id == "None") {
// pass
} else {
step = expr.Revert(concreteSlice.step);
}
}
index = new SliceExpression(start, stop, step, stepProvided);
} else if (slice is Ellipsis) {
index = new ConstantExpression(PythonOps.Ellipsis);
} else if (slice is ExtSlice) {
index = new TupleExpression(true, ((ExtSlice)slice).Revert());
} else {
Debug.Assert(false, "Unexpected type when converting Subscript: " + slice.GetType());
}
return new IndexExpression(expr.Revert(value), index);
}
private Expression MakeTupleOrExpr(List<Expression> l, bool trailingComma, bool expandable) {
if (l.Count == 1 && !trailingComma) return l[0];
Expression[] exprs = l.ToArray();
TupleExpression te = new TupleExpression(expandable && !trailingComma, exprs);
if (exprs.Length > 0) {
te.SetLoc(_globalParent, exprs[0].StartIndex, exprs[exprs.Length - 1].EndIndex);
}
return te;
}
public override bool Walk(TupleExpression node) => WalkItems(node.Items);