private TypeParamNode ToTypeParamNode(TypeParameter tp, DocComment dc)
{
Console.WriteLine("Type parameter: " + tp.Name);
return(new TypeParamNode {
Name = tp.Name,
UserDoc = dc == null || dc.TypeParamTags == null ? null : dc.TypeParamTags[tp.Name],
Token = ToTokenNode(tp.tok),
});
}
private SpecNode ToSpecNode(AttributedExpression expr, string kind, TokenNode token)
{
Console.WriteLine("Specification (" + kind + ")");
var dc = new DocComment(expr.DocComment);
return(new SpecNode {
Kind = kind,
Clause = Printer.ExprToString(expr.E),
UserDoc = dc.MainBody,
Token = token,
});
}
private ModuleNode ToModuleNode(ModuleDefinition mod, DocComment dc)
{
Console.WriteLine("Module: " + mod.Name);
return(new ModuleNode {
Name = mod.Name,
IsAbstract = mod.IsAbstract,
Refines = mod.RefinementQId == null ? null : mod.RefinementQId.ToString(),
Decls = CollectDecls(mod).Select(ToDeclNode).Where(d => d != null).ToList(),
UserDoc = dc == null ? null : dc.MainBody,
Token = ToTokenNode(mod.tok),
});
}
private FieldNode ToFieldNode(Field f)
{
Console.WriteLine("Field: " + f.Name);
var dc = new DocComment(f.DocComment);
var token = ToTokenNode(f.tok);
return(new FieldNode {
Name = f.Name,
Type = ToTypeRefNode(f.Type, token),
UserDoc = dc.MainBody,
Token = token,
});
}
private TypeSynonymNode ToTypeSynonymNode(OpaqueTypeDecl ot)
{
Console.WriteLine("Type synonym: " + ot.Name);
var dc = new DocComment(ot.DocComment);
return(new TypeSynonymNode {
Name = ot.Name,
TypeParams = ot.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
Rhs = null,
UserDoc = dc.MainBody,
Token = ToTokenNode(ot.tok),
});
}
private TypeSynonymNode ToTypeSynonymNode(TypeSynonymDecl ts)
{
Console.WriteLine("Type synonym: " + ts.Name);
var dc = new DocComment(ts.DocComment);
return(new TypeSynonymNode {
Name = ts.Name,
TypeParams = ts.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
Rhs = ts.Rhs.ToString(),
UserDoc = dc.MainBody,
Token = ToTokenNode(ts.tok),
});
}
private NewtypeNode ToNewtypeNode(NewtypeDecl nt)
{
Console.WriteLine("Newtype: " + nt.Name);
var dc = new DocComment(nt.DocComment);
var token = ToTokenNode(nt.tok);
return(new NewtypeNode {
Name = nt.Name,
BaseType = ToTypeRefNode(nt.BaseType, token),
Constraint = Printer.ExprToString(nt.Constraint),
UserDoc = dc.MainBody,
Token = ToTokenNode(nt.tok),
});
}
private FunctionNode ToFunctionNode(Function f)
{
Console.WriteLine("Function: " + f.Name);
var dc = new DocComment(f.DocComment);
var modifiers = new List <string>();
if (f.IsGhost)
{
modifiers.Add("ghost");
}
if (f.IsStatic)
{
modifiers.Add("static");
}
var token = ToTokenNode(f.tok);
var spec = new List <SpecNode>();
foreach (var req in f.Req)
{
spec.Add(ToSpecNode(req, "requires", token));
}
foreach (var ens in f.Ens)
{
spec.Add(ToSpecNode(ens, "ensures", token));
}
foreach (var reads in f.Reads)
{
spec.Add(ToSpecNode(reads, "reads", token));
}
spec.Add(ToSpecNode(f.Decreases, "decreases", token));
return(new FunctionNode {
Name = f.Name,
Kind =
f is GreatestPredicate ? "greatest predicate"
: f is LeastPredicate ? "least predicate"
: f is Predicate || f is TwoStatePredicate ?
f.IsGhost ? "predicate"
: "predicate method"
: f.IsGhost ? "function"
: "function method",
Modifiers = modifiers,
TypeParams = f.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
ValueParams = f.Formals.Select(vp => ToValueParamNode(vp, dc, false)).ToList(),
ReturnType = ToTypeRefNode(f.ResultType, token),
Spec = spec,
UserDoc = dc.MainBody,
Token = token,
});
}
private ClassNode ToClassNode(ClassDecl cl)
{
Console.WriteLine("Class: " + cl.Name);
var dc = new DocComment(cl.DocComment);
return(new ClassNode {
Name = cl.Name,
IsTrait = cl is TraitDecl,
TypeParams = cl.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
Extends = cl.ParentTraits.Select(t => t.ToString()).ToList(),
Members = cl.Members.Select(ToDeclNode).ToList(),
UserDoc = dc.MainBody,
Token = ToTokenNode(cl.tok),
});
}
private MethodNode ToMethodNode(Method m)
{
Console.WriteLine("Method: " + m.Name);
var dc = new DocComment(m.DocComment);
var modifiers = new List <string>();
if (m.IsGhost)
{
modifiers.Add("ghost");
}
if (m.IsStatic)
{
modifiers.Add("static");
}
var token = ToTokenNode(m.tok);
var spec = new List <SpecNode>();
foreach (var req in m.Req)
{
spec.Add(ToSpecNode(req, "requires", token));
}
foreach (var ens in m.Ens)
{
spec.Add(ToSpecNode(ens, "ensures", token));
}
spec.Add(ToSpecNode(m.Mod, "modifies", token));
spec.Add(ToSpecNode(m.Decreases, "decreases", token));
return(new MethodNode {
Name = m.Name,
Kind =
m is Constructor ? "constructor"
: m is GreatestLemma ? "greatest lemma"
: m is LeastLemma ? "least lemma"
: m is TwoStateLemma ? "twostate lemma"
: m is Lemma ? "lemma"
: "method",
Modifiers = modifiers,
TypeParams = m.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
ValueParams = m.Ins.Select(vp => ToValueParamNode(vp, dc, false)).ToList(),
Returns = m.Outs.Select(vp => ToValueParamNode(vp, dc, true)).ToList(),
Spec = spec,
UserDoc = dc.MainBody,
Token = token,
});
}
private ValueParamNode ToValueParamNode(Formal f, DocComment dc, bool isOut)
{
Console.WriteLine("Value parameter: " + f.Name);
string userDoc = null;
if (dc != null)
{
var tags = isOut ? dc.ReturnTags : dc.ValueParamTags;
if (tags != null)
{
userDoc = tags.GetValueOrDefault(f.Name);
}
}
var token = ToTokenNode(f.tok);
return(new ValueParamNode {
Name = f.Name,
Type = ToTypeRefNode(f.Type, token),
UserDoc = userDoc,
Token = token,
});
}
private DatatypeNode ToDatatypeNode(DatatypeDecl dt)
{
Console.WriteLine("Datatype: " + dt.Name);
var dc = new DocComment(dt.DocComment);
var ctors = new List <CtorNode>();
foreach (var ctor in dt.Ctors)
{
Console.WriteLine("Constructor: " + ctor.Name);
ctors.Add(new CtorNode {
Name = ctor.Name,
ValueParams = ctor.Formals.Select(f => ToValueParamNode(f, null, false)).ToList(),
Token = ToTokenNode(ctor.tok),
});
}
return(new DatatypeNode {
Name = dt.Name,
IsCodata = dt is CoDatatypeDecl,
TypeParams = dt.TypeArgs.Select(tp => ToTypeParamNode(tp, dc)).ToList(),
Ctors = ctors,
UserDoc = dc.MainBody,
});
}
