public override bool Walk(SetComprehension node)
{
EnsureComprehensionScope(node, MakeSetComprehensionScope);
Debug.Assert(_scope is ComprehensionScope);
return(base.Walk(node));
}
public override void PostWalk(SetComprehension node)
{
Debug.Assert(_scope is ComprehensionScope);
_scope = _scope.OuterScope;
base.PostWalk(node);
}
public override bool Walk(SetComprehension node)
{
if (_libraryMode)
{
return(false);
}
_stack.Enter(SymbolKind.None);
return(base.Walk(node));
}
public CodeExpression VisitSetComprehension(SetComprehension sc)
{
m.EnsureImport("System.Linq");
var compFor = (CompFor)sc.Collection;
var v = sc.Projection.Accept(this);
var c = TranslateToLinq(v, compFor);
return(m.Appl(
m.MethodRef(
c,
"ToHashSet")));
}
// SetComp
public override bool Walk(SetComprehension node)
{
BitArray save = _bits;
_bits = new BitArray(_bits);
foreach (ComprehensionIterator iter in node.Iterators)
{
iter.Walk(this);
}
node.Item.Walk(this);
_bits = save;
return(false);
}
public string GenerateConditionString(SetComprehension expression, IDictionary <string, string> rename)
{
var bob = new StringBuilder();
bob.Append(expression.tok.val + " "); // appends "set "
string boundName = expression.BoundVars.First().Name; // Assume for now that only a single bound variable exists.
bob.Append(boundName + " | " + GenerateConditionString(expression.Range, rename));
// Not all set comprehension expressions contain a "Term" section.
// For example: set x | x in {0,1,2,3,4,5} && x < 3;
if (expression.Term.tok.val != "set")
{
bob.Append(" :: ");
bob.Append(GenerateConditionString(expression.Term, rename));
}
return(bob.ToString());
}
void SetComprehensionExpr(IToken setToken, bool finite, out Expression q, bool allowSemi, bool allowLambda)
{
Contract.Ensures(Contract.ValueAtReturn(out q) != null);
BoundVar bv;
List<BoundVar/*!*/> bvars = new List<BoundVar>();
Expression range;
Expression body = null;
Attributes attrs = null;
IdentTypeOptional(out bv);
bvars.Add(bv);
while (la.kind == 22) {
Get();
IdentTypeOptional(out bv);
bvars.Add(bv);
}
while (la.kind == 46) {
Attribute(ref attrs);
}
Expect(23);
Expression(out range, allowSemi, allowLambda);
if (IsQSep()) {
QSep();
Expression(out body, allowSemi, allowLambda);
}
if (body == null && bvars.Count != 1) { SemErr(t, "a set comprehension with more than one bound variable must have a term expression"); }
q = new SetComprehension(setToken, finite, bvars, range, body, attrs);
}
public override bool Walk(SetComprehension node)
{
node.Walk(new ComprehensionWalker(_walker, _localNames, _localNameExpressions));
return(false);
}
public override void PostWalk(SetComprehension node)
{
}
public void VisitSetComprehension(SetComprehension setComprehension)
{
throw new NotImplementedException();
}
// SetComprehension
public override bool Walk(SetComprehension node)
{
return(Location >= node.StartIndex && Location <= node.EndIndex);
}
public override void PostWalk(SetComprehension node)
{
PostWalkWorker(node);
}
// SetComprehension
public override bool Walk(SetComprehension node)
{
return false;
}
public override bool Walk(SetComprehension node)
{
ProcessComprehension(node, node.Item, node.Iterators);
return(false);
}
public virtual void PostWalk(SetComprehension node)
{
}
public override void PostWalk(SetComprehension node)
{
}
// SetComprehension
public virtual bool Walk(SetComprehension node)
{
return true;
}
public override bool Walk(SetComprehension node)
{
return(UpdateLineInfo(node, true));
}
public virtual void PostWalk(SetComprehension node)
{
}
public CodeExpression VisitSetComprehension(SetComprehension sc)
{
var compFor = (CompFor)sc.Collection;
var v = compFor.variable.Accept(this);
var c = Translate(v, compFor);
if (IsIdentityProjection(compFor, sc.Projection))
{
return(m.Appl(
m.MethodRef(
c,
"ToHashSet")));
}
else if (v is CodeVariableReferenceExpression)
{
return(m.Appl(
m.MethodRef(
c,
"ToHashSet"),
m.Lambda(
new CodeExpression[] { v },
sc.Projection.Accept(this))));
}
else
{
var varList = (ExpList)compFor.variable;
return
(m.Appl(
m.MethodRef(
m.Appl(
m.MethodRef(
c,
"Chop"),
m.Lambda(
varList.Expressions.Select(e => e.Accept(this)).ToArray(),
sc.Projection.Accept(this))),
"ToHashSet")));
}
#if NO
var list = dc.source.collection.Accept(this);
var varList = dc.source.variable as ExpList;
if (varList != null)
{
if (varList.Expressions.Count != 2)
{
throw new InvalidOperationException("Variable list should contain one or two variables.");
}
var k = (Identifier)varList.Expressions[0];
var v = (Identifier)varList.Expressions[1];
var kValue = dc.key.Accept(this);
var vValue = dc.value.Accept(this);
return(m.Appl(
new CodeMethodReferenceExpression(
list,
"ToDictionary"),
m.Lambda(new CodeExpression[] { k.Accept(this) }, kValue),
m.Lambda(new CodeExpression[] { v.Accept(this) }, vValue)));
}
var id = sc dc.source.variable as Identifier;
if (id != null)
{
var vValue = dc.value.Accept(this);
return(m.Appl(
new CodeMethodReferenceExpression(
list,
"ToHashSet"),
m.Lambda(new CodeExpression[] { id.Accept(this) }, vValue)));
}
var tuple = dc.source.variable as PyTuple;
if (tuple != null)
{
//TODO: tuples, especially nested tuples, are hard.
return(new CodePrimitiveExpression("!!!{" +
dc.key.Accept(this) +
": " +
dc.value.Accept(this)));
}
#endif
}
// SetComprehension
public override bool Walk(SetComprehension node)
{
return(ShouldWalkWorker(node));
}
public DataType VisitSetComprehension(SetComprehension s)
{
s.Collection.Accept(this);
return(new SetType(s.Projection.Accept(this)));
}
public void VisitSetComprehension(SetComprehension setComprehension)
{
throw new NotImplementedException();
}
// SetComprehension
public virtual bool Walk(SetComprehension node)
{
return(true);
}
public override bool Walk(SetComprehension node)
{
_stack.Enter(SymbolKind.None);
return(base.Walk(node));
}
// SetComprehension
public override bool Walk(SetComprehension node)
{
return(false);
}
public override void PostWalk(SetComprehension node) => ExitComprehension(node);
private static bool ShallowEq(SetComprehension expr1, SetComprehension expr2)
{
return(expr1.TermIsImplicit == expr2.TermIsImplicit && //TODO
expr1.Finite == expr2.Finite);
}
// SetComprehension
public override bool Walk(SetComprehension node) { return Location >= node.StartIndex && Location <= node.EndIndex; }