// ----------------------------------------------------------------------
// Building type structures
// ----------------------------------------------------------------------
private void BuildTypeStructure(Seq <JST.Statement> body)
{
// Already bound: T, Id, Assembly, Name, Slot
var compiler = new TypeCompiler(this);
compiler.Emit(body);
if (TyconEnv.Type.Arity > 0)
{
// Methods live on type definition itself if type is higher-kinded
if (Env.DebugMode)
{
body.Add(new JST.CommentStatement("Method definitions (accepting type-bound type arguments)"));
}
EmitMethods(body, TypeDefinitionId.ToE(), NameSupply, TypeDefinitionId.ToE(), false);
EmitMethods(body, TypeDefinitionId.ToE(), NameSupply, TypeDefinitionId.ToE(), true);
}
// Shared strings
if (Env.DebugMode)
{
body.Add(new JST.CommentStatement("Shared strings"));
}
foreach (var kv in Env.GlobalMapping.AllStringSlots(TyconEnv.Assembly, TyconEnv.Type))
{
body.Add
(JST.Statement.DotAssignment
(TypeDefinitionId.ToE(),
new JST.Identifier(Constants.TypeStringSlot(kv.Value)),
new JST.StringLiteral(kv.Key)));
}
}
private CompiledModel ComileAssembly(LoadedClasses classes)
{
TypeCompiler compiler = new TypeCompiler();
compiler.AddGivenTypes(GetGivenTypesContents());
return(compiler.Compile(
classes.Files.Values
.Select(file => file.Contents)));
}
public void TestCompileOneType()
{
TypeCompiler compiler = new TypeCompiler();
CompiledModel oneType = compiler.Compile(new [] { testClassContent });
Type type = oneType.GetType(TestClass);
Assert.AreEqual(type.Name, TestClass);
}
public Type CreateDynamicAssertType()
{
if (ReceivedStatement == null)
{
ReceivedStatement = "Received(1)";
}
if (ArgStatement == null)
{
ArgStatement = $"Arg.Any<{RequestType.Name}>()";
}
if (ReturnsStatement == null)
{
ReturnsStatement = $"new {ResponseType.Name}()";
}
SourceCodeBuilder code = new SourceCodeBuilder();
code.AppendLine("using System;");
code.AppendLine("using System.Threading.Tasks;");
code.AppendLine($"using {typeof(IDynamicMock).Namespace};");
code.AppendLine($"using {typeof(NSubstitute.Substitute).Namespace};");
code.AppendLine($"using {typeof(ICommandHandler<,>).Namespace};");
code.AppendLine($"using {typeof(MockRegister).Namespace};");
code.AppendLine($"using {RequestType.Namespace};");
code.AppendLine("namespace DynamicUtils").OpenBlock();
code.AppendLine($"public class DynamicMock : {typeof(IDynamicMock).Name}").OpenBlock();
code.AppendLine("private MockRegister _register;");
code.AppendLine($"public async Task Execute()").OpenBlock();
var handler = $"_register.GetHandler<{RequestType.Name},{ResponseType.Name}>()";
if (IsAssertion)
{
code.AppendLine($"await {handler}.{ReceivedStatement}.Execute({ArgStatement});");
}
else
{
code.AppendLine($"{handler}.Execute({ArgStatement}).Returns({ReturnsStatement});");
}
code.CloseBlock();
code.AppendLine($"public DynamicMock(MockRegister register)").OpenBlock();
code.AppendLine("this._register = register;").CloseBlock();
code.CloseBlock().CloseBlock();
TypeCompiler compiler = new TypeCompiler();
var assertationAssembly = compiler.FastLoad(code.ToString(),
RequestType.Assembly,
typeof(ValueTask <>).Assembly,
Assembly.Load("System.Threading.Tasks.Extensions, Version=4.1.0.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51"));
return(assertationAssembly.GetType("DynamicUtils.DynamicMock"));
}
public void TestCompileWithGivenTypes()
{
TypeCompiler compiler = new TypeCompiler();
compiler.AddGivenTypes(
new [] { testClassContent });
CompiledModel oneType = compiler.Compile(
new[] { usingTestClassContent });
Type type = oneType.GetType(UsingTestClass);
Assert.AreEqual(type.Name, UsingTestClass);
}
public void TestCompileTwoTypes()
{
TypeCompiler compiler = new TypeCompiler();
CompiledModel twoTypes = compiler.Compile(
new []
{
testClassContent,
usingTestClassContent
});
Type type = twoTypes.GetType(UsingTestClass);
Assert.AreEqual(type.Name, UsingTestClass);
}
public async Task WhenACommandhandlerIsGenerated(string handlerName)
{
var result = await this._applicationExecutor.ExecuteAsync <ISqlCqrsGenerator, SourceUnitCollection>(x => x.Generate(0));
DynamicAssembly assembly = new DynamicAssembly(NSubstitute.Substitute.For <IEventHub>());
assembly.AppendSourceUnits(result);
assembly.AddDefaultReferences();
TypeCompiler compiler = new TypeCompiler();
_context["assembly"] = assembly.Compile(compiler);
assembly.Assembly.GetTypes().Should().Contain(x => x.Name == handlerName);
}
public DynamicAssembly Compile(ITypeCompiler compiler = null)
{
if (compiler == null)
{
compiler = new TypeCompiler();
}
Stopwatch s = new Stopwatch();
s.Start();
try
{
_assembly = compiler.FastLoad(_sourceUnits.Code, _references.ToArray());
s.Stop();
CompilationDate = DateTimeOffset.Now;
CompilationDuration = s.Elapsed;
_eventHub.Publish(new AssemblyCompiledEvent()
{
Assembly = _assembly,
Duration = CompilationDuration,
SourceCode = _sourceUnits,
When = CompilationDate,
Purpose = this.Purpose,
Data = File.ReadAllBytes(_assembly.Location)
});
}
catch (Exception ex)
{
s.Stop();
CompilationDate = DateTimeOffset.Now;
CompilationDuration = s.Elapsed;
_eventHub.Publish(new AssemblyCompiledEvent()
{
Assembly = _assembly,
Duration = CompilationDuration,
SourceCode = _sourceUnits,
When = CompilationDate,
Purpose = this.Purpose,
Errors = ex.Message
});
throw;
}
return(this);
}
public void GivenIHaveWrittenCommandAndResultAs(string commandTypes, Table table)
{
var lines = table.CreateSet <CSharpCode>().ToArray();
SourceCodeBuilder sb = new SourceCodeBuilder();
sb.AppendLine("using System;");
sb.AppendLine("namespace Test").OpenBlock();
sb.AppendLines(lines.Select(x => x.Code)).CloseBlock();
TypeCompiler compiler = new TypeCompiler();
var typeAssembly = compiler.FastLoad(sb.ToString());
foreach (var commandType in commandTypes.Split(','))
{
_data.Types[commandType] = typeAssembly.GetType($"Test.{commandType}");
}
_data.Types["UserEntity"] = typeAssembly.GetType("Test.UserEntity");
}
public void TestCompileNull()
{
TypeCompiler compiler = new TypeCompiler();
compiler.Compile(null);
}
public void TestCompileNothing()
{
TypeCompiler compiler = new TypeCompiler();
compiler.Compile(new string[0]);
}
