public static string IteratorClassToString(IteratorDecl iter) {
Contract.Requires(iter != null);
using (var wr = new System.IO.StringWriter()) {
var pr = new Printer(wr);
pr.PrintIteratorClass(iter, 0, null);
return ToStringWithoutNewline(wr);
}
}
void IteratorDecl(ModuleDefinition module, out IteratorDecl/*!*/ iter)
{
Contract.Ensures(Contract.ValueAtReturn(out iter) != null);
IToken/*!*/ id;
Attributes attrs = null;
List<TypeParameter/*!*/>/*!*/ typeArgs = new List<TypeParameter/*!*/>();
List<Formal/*!*/> ins = new List<Formal/*!*/>();
List<Formal/*!*/> outs = new List<Formal/*!*/>();
List<FrameExpression/*!*/> reads = new List<FrameExpression/*!*/>();
List<FrameExpression/*!*/> mod = new List<FrameExpression/*!*/>();
List<Expression/*!*/> decreases = new List<Expression>();
List<MaybeFreeExpression/*!*/> req = new List<MaybeFreeExpression/*!*/>();
List<MaybeFreeExpression/*!*/> ens = new List<MaybeFreeExpression/*!*/>();
List<MaybeFreeExpression/*!*/> yieldReq = new List<MaybeFreeExpression/*!*/>();
List<MaybeFreeExpression/*!*/> yieldEns = new List<MaybeFreeExpression/*!*/>();
List<Expression/*!*/> dec = new List<Expression/*!*/>();
Attributes readsAttrs = null;
Attributes modAttrs = null;
Attributes decrAttrs = null;
BlockStmt body = null;
IToken signatureEllipsis = null;
IToken bodyStart = Token.NoToken;
IToken bodyEnd = Token.NoToken;
while (!(la.kind == 0 || la.kind == 81)) {SynErr(148); Get();}
Expect(81);
while (la.kind == 46) {
Attribute(ref attrs);
}
NoUSIdent(out id);
if (la.kind == 50 || la.kind == 52) {
if (la.kind == 52) {
GenericParameters(typeArgs);
}
Formals(true, true, ins);
if (la.kind == 82 || la.kind == 83) {
if (la.kind == 82) {
Get();
} else {
Get();
SemErr(t, "iterators don't have a 'returns' clause; did you mean 'yields'?");
}
Formals(false, true, outs);
}
} else if (la.kind == 59) {
Get();
signatureEllipsis = t;
} else SynErr(149);
while (StartOf(5)) {
IteratorSpec(reads, mod, decreases, req, ens, yieldReq, yieldEns, ref readsAttrs, ref modAttrs, ref decrAttrs);
}
if (la.kind == 46) {
BlockStmt(out body, out bodyStart, out bodyEnd);
}
iter = new IteratorDecl(id, id.val, module, typeArgs, ins, outs,
new Specification<FrameExpression>(reads, readsAttrs),
new Specification<FrameExpression>(mod, modAttrs),
new Specification<Expression>(decreases, decrAttrs),
req, ens, yieldReq, yieldEns,
body, attrs, signatureEllipsis);
iter.BodyStartTok = bodyStart;
iter.BodyEndTok = bodyEnd;
}
private void PrintIteratorClass(IteratorDecl iter, int indent, string fileBeingPrinted) {
PrintClassMethodHelper("class", null, iter.Name, iter.TypeArgs);
wr.WriteLine(" {");
PrintMembers(iter.Members, indent + IndentAmount, fileBeingPrinted);
Indent(indent); wr.WriteLine("}");
}
void PrintIteratorSignature(IteratorDecl iter, int indent) {
Indent(indent);
PrintClassMethodHelper("iterator", iter.Attributes, iter.Name, iter.TypeArgs);
if (iter.SignatureIsOmitted) {
wr.WriteLine(" ...");
} else {
PrintFormals(iter.Ins);
if (iter.Outs.Count != 0) {
if (iter.Ins.Count + iter.Outs.Count <= 3) {
wr.Write(" yields ");
} else {
wr.WriteLine();
Indent(indent + 2 * IndentAmount);
wr.Write("yields ");
}
PrintFormals(iter.Outs);
}
wr.WriteLine();
}
int ind = indent + IndentAmount;
PrintSpec("requires", iter.Requires, ind);
if (iter.Reads.Expressions != null) {
PrintFrameSpecLine("reads", iter.Reads.Expressions, ind, iter.Reads.HasAttributes() ? iter.Reads.Attributes : null);
}
if (iter.Modifies.Expressions != null) {
PrintFrameSpecLine("modifies", iter.Modifies.Expressions, ind, iter.Modifies.HasAttributes() ? iter.Modifies.Attributes : null);
}
PrintSpec("yield requires", iter.YieldRequires, ind);
PrintSpec("yield ensures", iter.YieldEnsures, ind);
PrintSpec("ensures", iter.Ensures, ind);
PrintDecreasesSpec(iter.Decreases, ind);
}
// -------------------------------------------------- Merging ---------------------------------------------------------------
IteratorDecl MergeIterator(IteratorDecl nw, IteratorDecl prev)
{
Contract.Requires(nw != null);
Contract.Requires(prev != null);
if (nw.Requires.Count != 0) {
reporter.Error(MessageSource.RefinementTransformer, nw.Requires[0].E.tok, "a refining iterator is not allowed to add preconditions");
}
if (nw.YieldRequires.Count != 0) {
reporter.Error(MessageSource.RefinementTransformer, nw.YieldRequires[0].E.tok, "a refining iterator is not allowed to add yield preconditions");
}
if (nw.Reads.Expressions.Count != 0) {
reporter.Error(MessageSource.RefinementTransformer, nw.Reads.Expressions[0].E.tok, "a refining iterator is not allowed to extend the reads clause");
}
if (nw.Modifies.Expressions.Count != 0) {
reporter.Error(MessageSource.RefinementTransformer, nw.Modifies.Expressions[0].E.tok, "a refining iterator is not allowed to extend the modifies clause");
}
if (nw.Decreases.Expressions.Count != 0) {
reporter.Error(MessageSource.RefinementTransformer, nw.Decreases.Expressions[0].tok, "a refining iterator is not allowed to extend the decreases clause");
}
if (nw.SignatureIsOmitted) {
Contract.Assert(nw.TypeArgs.Count == 0);
Contract.Assert(nw.Ins.Count == 0);
Contract.Assert(nw.Outs.Count == 0);
reporter.Info(MessageSource.RefinementTransformer, nw.SignatureEllipsis, Printer.IteratorSignatureToString(prev));
} else {
CheckAgreement_TypeParameters(nw.tok, prev.TypeArgs, nw.TypeArgs, nw.Name, "iterator");
CheckAgreement_Parameters(nw.tok, prev.Ins, nw.Ins, nw.Name, "iterator", "in-parameter");
CheckAgreement_Parameters(nw.tok, prev.Outs, nw.Outs, nw.Name, "iterator", "yield-parameter");
}
BlockStmt newBody;
if (nw.Body == null) {
newBody = prev.Body;
} else if (prev.Body == null) {
newBody = nw.Body;
} else {
newBody = MergeBlockStmt(nw.Body, prev.Body);
}
var ens = prev.Ensures.ConvertAll(rawCloner.CloneMayBeFreeExpr);
ens.AddRange(nw.Ensures);
var yens = prev.YieldEnsures.ConvertAll(rawCloner.CloneMayBeFreeExpr);
yens.AddRange(nw.YieldEnsures);
return new IteratorDecl(new RefinementToken(nw.tok, moduleUnderConstruction),
nw.Name, moduleUnderConstruction,
nw.SignatureIsOmitted ? prev.TypeArgs.ConvertAll(refinementCloner.CloneTypeParam) : nw.TypeArgs,
nw.SignatureIsOmitted ? prev.Ins.ConvertAll(refinementCloner.CloneFormal) : nw.Ins,
nw.SignatureIsOmitted ? prev.Outs.ConvertAll(refinementCloner.CloneFormal) : nw.Outs,
refinementCloner.CloneSpecFrameExpr(prev.Reads),
refinementCloner.CloneSpecFrameExpr(prev.Modifies),
refinementCloner.CloneSpecExpr(prev.Decreases),
prev.Requires.ConvertAll(refinementCloner.CloneMayBeFreeExpr),
ens,
prev.YieldRequires.ConvertAll(refinementCloner.CloneMayBeFreeExpr),
yens,
newBody,
refinementCloner.MergeAttributes(prev.Attributes, nw.Attributes),
null);
}
public TopLevelDecl CloneDeclaration(TopLevelDecl d, ModuleDefinition m) {
Contract.Requires(d != null);
Contract.Requires(m != null);
if (d is OpaqueTypeDecl) {
var dd = (OpaqueTypeDecl)d;
return new OpaqueTypeDecl(Tok(dd.tok), dd.Name, m, dd.EqualitySupport, dd.TypeArgs.ConvertAll(CloneTypeParam), CloneAttributes(dd.Attributes), d);
} else if (d is TypeSynonymDecl) {
var dd = (TypeSynonymDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
return new TypeSynonymDecl(Tok(dd.tok), dd.Name, tps, m, CloneType(dd.Rhs), CloneAttributes(dd.Attributes), dd);
} else if (d is NewtypeDecl) {
var dd = (NewtypeDecl)d;
if (dd.Var == null) {
return new NewtypeDecl(Tok(dd.tok), dd.Name, m, CloneType(dd.BaseType), CloneAttributes(dd.Attributes), dd);
} else {
return new NewtypeDecl(Tok(dd.tok), dd.Name, m, CloneBoundVar(dd.Var), CloneExpr(dd.Constraint), CloneAttributes(dd.Attributes), dd);
}
} else if (d is TupleTypeDecl) {
var dd = (TupleTypeDecl)d;
return new TupleTypeDecl(dd.Dims, dd.Module);
} else if (d is IndDatatypeDecl) {
var dd = (IndDatatypeDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var ctors = dd.Ctors.ConvertAll(CloneCtor);
var dt = new IndDatatypeDecl(Tok(dd.tok), dd.Name, m, tps, ctors, CloneAttributes(dd.Attributes), dd);
return dt;
} else if (d is CoDatatypeDecl) {
var dd = (CoDatatypeDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var ctors = dd.Ctors.ConvertAll(CloneCtor);
var dt = new CoDatatypeDecl(Tok(dd.tok), dd.Name, m, tps, ctors, CloneAttributes(dd.Attributes), dd);
return dt;
} else if (d is IteratorDecl) {
var dd = (IteratorDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var ins = dd.Ins.ConvertAll(CloneFormal);
var outs = dd.Outs.ConvertAll(CloneFormal);
var reads = CloneSpecFrameExpr(dd.Reads);
var mod = CloneSpecFrameExpr(dd.Modifies);
var decr = CloneSpecExpr(dd.Decreases);
var req = dd.Requires.ConvertAll(CloneMayBeFreeExpr);
var yreq = dd.YieldRequires.ConvertAll(CloneMayBeFreeExpr);
var ens = dd.Ensures.ConvertAll(CloneMayBeFreeExpr);
var yens = dd.YieldEnsures.ConvertAll(CloneMayBeFreeExpr);
var body = CloneBlockStmt(dd.Body);
var iter = new IteratorDecl(Tok(dd.tok), dd.Name, dd.Module,
tps, ins, outs, reads, mod, decr,
req, ens, yreq, yens,
body, CloneAttributes(dd.Attributes), dd.SignatureEllipsis);
return iter;
} else if (d is TraitDecl) {
if (d is DefaultClassDecl) {
var dd = (TraitDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var mm = dd.Members.ConvertAll(CloneMember);
var cl = new DefaultClassDecl(m, mm);
return cl;
} else {
var dd = (TraitDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var mm = dd.Members.ConvertAll(CloneMember);
var cl = new TraitDecl(Tok(dd.tok), dd.Name, m, tps, mm, CloneAttributes(dd.Attributes), dd);
return cl;
}
} else if (d is ClassDecl) {
var dd = (ClassDecl)d;
var tps = dd.TypeArgs.ConvertAll(CloneTypeParam);
var mm = dd.Members.ConvertAll(CloneMember);
if (d is DefaultClassDecl) {
return new DefaultClassDecl(m, mm, ((DefaultClassDecl)d));
} else {
return new ClassDecl(Tok(dd.tok), dd.Name, m, tps, mm, CloneAttributes(dd.Attributes), dd.TraitsTyp.ConvertAll(CloneType), dd);
}
} else if (d is ModuleDecl) {
if (d is LiteralModuleDecl) {
var l = new LiteralModuleDecl(((LiteralModuleDecl)d).ModuleDef, m);
l.Signature = ((ModuleDecl)d).Signature;
return l;
} else if (d is AliasModuleDecl) {
var a = (AliasModuleDecl)d;
var alias = new AliasModuleDecl(a.Path, a.tok, m, a.Opened);
alias.Signature = a.Signature;
return alias;
} else if (d is ModuleFacadeDecl) {
var a = (ModuleFacadeDecl)d;
var abs = new ModuleFacadeDecl(a.Path, a.tok, m, a.CompilePath, a.Opened);
abs.Signature = a.Signature;
abs.OriginalSignature = a.OriginalSignature;
return abs;
} else if (d is ModuleExportDecl) {
var a = (ModuleExportDecl)d;
var export = new ModuleExportDecl(a.tok, m, a.IsDefault, a.Exports, a.Extends);
export.Signature = a.Signature;
return export;
} else {
Contract.Assert(false); // unexpected declaration
return null; // to please compiler
}
} else {
Contract.Assert(false); // unexpected declaration
return null; // to please compiler
}
}