public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
Block init; Expression test; Block body, iter;
if (IsWhileDo)
{
init = transformer.Transform(Init).AssertCast <Block>();
test = transformer.Transform(Test).AssertCast <Expression>();
body = transformer.Transform(Body).AssertCast <Block>();
iter = transformer.Transform(Iter).AssertCast <Block>();
}
else
{
init = transformer.Transform(Init).AssertCast <Block>();
body = transformer.Transform(Body).AssertCast <Block>();
iter = transformer.Transform(Iter).AssertCast <Block>();
test = transformer.Transform(Test).AssertCast <Expression>();
}
var visited = new Loop(test, body, IsWhileDo)
{
Init = init, Iter = iter
};
visited.Locals.SetElements(Locals.Select(loc => loc.DeepClone()));
return(visited.HasProto(this));
}
else
{
return(transformer.TransformLoop(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
return(new Break().HasProto(this));
}
else
{
return(transformer.TransformBreak(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
return(null);
}
else
{
return(transformer.TransformNull(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
return(base.AcceptTransformer(transformer, false).HasProto(this));
}
else
{
return(transformer.TransformClause(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
return(new Const(Value, Type).HasProto(this));
}
else
{
return(transformer.TransformConst(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
return(new SizeOf(Type).HasProto(this));
}
else
{
return(transformer.TransformSizeof(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var exception = transformer.Transform(Exception).AssertCast <Expression>();
return(new Throw(exception).HasProto(this));
}
else
{
return(transformer.TransformThrow(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var value = transformer.Transform(Value).AssertCast <Expression>();
return(new Return(value).HasProto(this));
}
else
{
return(transformer.TransformReturn(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var @this = transformer.Transform(This).AssertCast <Expression>();
return(new Fld(Field, @this).HasProto(this));
}
else
{
return(transformer.TransformFld(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var target = transformer.Transform(Target).AssertCast <Expression>();
return(new Addr(target).HasProto(this));
}
else
{
return(transformer.TransformAddr(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var source = transformer.Transform(Source).AssertCast <Expression>();
return(new Convert(Type, source).HasProto(this));
}
else
{
return(transformer.TransformConvert(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var callee = transformer.Transform(Callee).AssertCast <Apply>();
return(new Eval(callee).HasProto(this));
}
else
{
return(transformer.TransformEval(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var @this = transformer.Transform(This).AssertCast <Expression>();
return(new Prop(Property, @this, InvokedAsVirtual).HasProto(this));
}
else
{
return(transformer.TransformProp(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var body = transformer.Transform(Body).AssertCast <Block>();
var clauses = Clauses.Select(c => transformer.Transform(c)).AssertCast <Clause>();
return(new Try(body, clauses).HasProto(this));
}
else
{
return(transformer.TransformTry(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var clone = new Ref(Sym.DeepClone());
clone.Proto = this;
return(clone);
}
else
{
return(transformer.TransformRef(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var members = Members.ToDictionary(mi => mi, mi => transformer.Transform(MemberInits[mi]).AssertCast <Expression>());
var ctor = transformer.Transform(Ctor).AssertCast <Eval>();
return(new ObjectInit(ctor, members).HasProto(this));
}
else
{
return(transformer.TransformObjectInit(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var elements = Elements.Select(el => transformer.Transform(el)).AssertCast <Expression>();
var ctor = transformer.Transform(Ctor).AssertCast <Eval>();
return(new CollectionInit(ctor, elements).HasProto(this));
}
else
{
return(transformer.TransformCollectionInit(this.HasProto(this)));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var args = Args.Select(arg => transformer.Transform(arg)).AssertCast <Expression>();
var callee = transformer.Transform(Callee).AssertCast <Expression>();
return(new Apply(callee, args).HasProto(this));
}
else
{
return(transformer.TransformApply(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var rhs = transformer.Transform(Rhs).AssertCast <Expression>();
var lhs = transformer.Transform(Lhs).AssertCast <Expression>();
return(new Assign(lhs, rhs).HasProto(this));
}
else
{
return(transformer.TransformAssign(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var visited = new Goto();
visited.LabelId = LabelId;
return(visited.HasProto(this));
}
else
{
return(transformer.TransformGoto(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var visited = new Loophole().HasProto(this);
visited._id = _id;
visited.Tag = Tag;
return(this);
}
else
{
return(transformer.TransformLoophole(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var stmts = this.Select(stmt => transformer.Transform(stmt));
var visited = new Block(stmts.Where(stmt => stmt != null));
visited.Locals.SetElements(Locals.Select(loc => loc.DeepClone()));
return(visited.HasProto(this));
}
else
{
return(transformer.TransformBlock(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var visited = Method != null ? new Lambda(Method) : new Lambda(Sig);
visited.InvocationStyle = InvocationStyle;
visited._body = transformer.Transform(_body).AssertCast <Block>();
return(visited.HasProto(this));
}
else
{
return(transformer.TransformLambda(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var args = Args.Select(arg => transformer.Transform(arg)).AssertCast <Expression>();
var clone = Operator.Create(OperatorType, args);
clone.Proto = this;
return(clone);
}
else
{
return(transformer.TransformOperator(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var test = transformer.Transform(Test).AssertCast <Expression>();
var iftrue = transformer.Transform(IfTrue).AssertCast <Block>();
var iffalse = transformer.Transform(IfFalse).AssertCast <Block>();
return(new If(test, iftrue, iffalse).HasProto(this));
}
else
{
return(transformer.TransformIf(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
var init = transformer.Transform(Init).AssertCast <Expression>();
var body = transformer.Transform(Body).AssertCast <Block>();
var visited = new Using(init, body);
visited.Locals.SetElements(Locals.Select(loc => loc.DeepClone()));
return(visited.HasProto(this));
}
else
{
return(transformer.TransformUsing(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
// todo. think about how to implement this without multiple clone operations
var clause = base.AcceptTransformer(transformer, false);
if (clause is Block && !(clause is Clause))
{
var visited = new Finally(clause);
visited.Locals.SetElements(Locals.Select(loc => loc.DeepClone()));
return(visited.HasProto(this));
}
else
{
return(clause.HasProto(this));
}
}
else
{
return(transformer.TransformFinally(this).HasProto(this));
}
}
public override Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl)
{
if (forceDefaultImpl)
{
// todo. think about how to implement this without multiple clone operations
var clause = base.AcceptTransformer(transformer, false);
if (clause is Block && !(clause is Clause))
{
var filter = transformer.Transform(Filter).AssertCast <Lambda>();
var visited = new Catch(ExceptionType, filter, clause);
visited.Locals.SetElements(Locals.Select(loc => loc.DeepClone()));
return(visited.HasProto(this));
}
else
{
return(clause.HasProto(this));
}
}
else
{
return(transformer.TransformCatch(this).HasProto(this));
}
}
public abstract Node AcceptTransformer(AbstractHirTransformer transformer, bool forceDefaultImpl);
