private MethodDeclarationSyntax PayloadConstructionMethod(ITestDataRecord tdr)
{
TypeSyntax retType = null;
if (tdr.RecordType.IsAnonymousType())
{
retType = AnonymousDictionaryType;
}
else if (tdr.RecordType.IsCollection())
{
retType = GetCollectionReturnType(tdr.RecordType);
}
else
{
retType = tdr.RecordType.TypeName(_usings);
}
var md = MethodDeclaration(retType, CurrentMethodName);
var body = PayloadConstructionMethodBody(tdr);
return(md.WithBody(Block(SeparatedList <StatementSyntax>(body)))
.WithModifiers(
TokenList(
new[]
{
Token(SyntaxKind.PrivateKeyword)
})));
;
}
private IEnumerable <StatementSyntax> PayloadConstructionMethodBody(ITestDataRecord tdr)
{
if (tdr.Payload == null)
{
yield return(ReturnStatement(LiteralExpression(SyntaxKind.NullLiteralExpression)));
yield break;
}
if (tdr.RecordType.IsInlineable())
{
yield return(ReturnStatement(TypeInitConstructor.Construct(tdr.RecordType, tdr.Payload)));
yield break;
}
var ctx = new GenerationContext(_usings);
if (tdr is AnonymousTestDataRecord anon)
{
}
if (tdr.RecordType.IsEnumerable() || tdr.RecordType.IsTuple())
{
var coll =
tdr.RecordType.IsTuple()
? SyntaxGeneration.Generator.ProceedTuple(_tgr, tdr.Payload.GetTupleValues(), ctx)
: SyntaxGeneration.Generator.ProceedCollection(_tgr, tdr.RecordType, (IEnumerable)tdr.Payload, ctx);
foreach (var s in ctx.Declarations)
{
yield return(s);
}
foreach (var s in ctx.LateBound)
{
yield return(s);
}
yield return(ReturnStatement(coll));
yield break;
}
var gen = _tgr.GetGeneratorFor(tdr.RecordType);
gen.Proceed(tdr.Payload, ctx);
foreach (var statementSyntax in ctx.Declarations)
{
yield return(statementSyntax);
}
foreach (var statementSyntax in ctx.LateBound)
{
yield return(statementSyntax);
}
}
internal void Proceed(IEnumerable <QueryRecord> queries)
{
foreach (var queryRecord in queries)
{
ITestDataRecord tdr = null;
var recordType = typeof(TestDataRecord <>).MakeGenericType(queryRecord.DataType);
tdr =
Activator.CreateInstance(recordType, new[] { queryRecord.Result }) as ITestDataRecord;
//}
tdr.Description = queryRecord.Annotation;
tdr.Hash = queryRecord.Hash;
_records.Enqueue(tdr);
}
}
internal void Proceed(IEnumerable <QueryRecord> queries)
{
foreach (var queryRecord in queries)
{
ITestDataRecord tdr = null;
//if (queryRecord.DataType.IsAnonymousType())
//{
// tdr = AnonymousTestDataRecord.FromAnonymousObject(queryRecord.Result, queryRecord.DataType);
//}
//else
//{
var recordType = typeof(TestDataRecord <>).MakeGenericType(queryRecord.DataType);
tdr =
Activator.CreateInstance(recordType, new[] { queryRecord.Result }) as ITestDataRecord;
//}
tdr.Description = queryRecord.Annotation;
tdr.Hash = queryRecord.Hash;
_records.Enqueue(tdr);
}
}
private YieldStatementSyntax ProduceYield(ITestDataRecord trd)
{
TypeSyntax type = null;
if (trd.RecordType.IsAnonymousType())
{
type = AnonymousRecordType;
}
else if (trd.RecordType.IsCollection() && trd.RecordType.ElementType().IsAnonymousType())
{
type = AnonymousCollectionRecordType;
}
else
{
type = trd.GetType().TypeName(_usings);
}
var hash = AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ITestDataRecord.Hash)),
TypeInitConstructor.Construct(typeof(string), trd.Hash));
var description = AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
IdentifierName(nameof(ITestDataRecord.Description)),
TypeInitConstructor.Construct(typeof(string), trd.Description));
//var data = AssignmentExpression(SyntaxKind.SimpleAssignmentExpression,
// IdentifierName(nameof(ITestDataRecord<int>.Data)),
// InvocationExpression(IdentifierName(CurrentMethodName)));
var invokeGetData = InvocationExpression(IdentifierName(CurrentMethodName));
var sto = (new SyntaxNodeOrToken[]
{ hash, Token(SyntaxKind.CommaToken), description });
var init = ObjectCreationExpression(type)
.WithArgumentList(ArgumentList(SingletonSeparatedList(Argument(invokeGetData))))
.WithInitializer(InitializerExpression(SyntaxKind.ObjectInitializerExpression,
SeparatedList <ExpressionSyntax>(sto)));
return(YieldStatement(SyntaxKind.YieldReturnStatement,
init));
}
private IEnumerable <StatementSyntax> PayloadConstructionMethodBody(ITestDataRecord tdr)
{
if (tdr.Payload == null)
{
yield return(ReturnStatement(LiteralExpression(SyntaxKind.NullLiteralExpression)));
yield break;
}
if (tdr.RecordType.IsInlineable())
{
yield return(ReturnStatement(TypeInitConstructor.Construct(tdr.RecordType, tdr.Payload)));
yield break;
}
var ctx = new GenerationContext(_usings);
if (tdr.RecordType.IsDictionary())
{
var dict = Generator.ProceedDictionary(_tgr, tdr.RecordType, (IDictionary)tdr.Payload, ctx);
foreach (var s in ctx.Declarations)
{
yield return(s);
}
foreach (var s in ctx.LateBound)
{
yield return(s);
}
yield return(ReturnStatement(dict));
yield break;
}
else if (tdr.RecordType.IsEnumerable() || tdr.RecordType.IsTuple())
{
var coll =
tdr.RecordType.IsTuple()
? SyntaxGeneration.Generator.ProceedTuple(_tgr, tdr.Payload.GetTupleValues(), ctx)
: SyntaxGeneration.Generator.ProceedCollection(_tgr, tdr.RecordType, (IEnumerable)tdr.Payload,
ctx, forceArray: true);
foreach (var s in ctx.Declarations)
{
yield return(s);
}
foreach (var s in ctx.LateBound)
{
yield return(s);
}
yield return(ReturnStatement(coll));
yield break;
}
var gen = _tgr.GetGeneratorFor(tdr.RecordType);
var result = gen.New(tdr.Payload, ctx);
while (ctx.Declarations.Count > 0)
{
yield return(ctx.Declarations.Dequeue());
}
while (ctx.LateBound.Count > 0)
{
yield return(ctx.LateBound.Dequeue());
}
yield return(ReturnStatement(result));
}
