// ---------------------------------------------------------------------- // 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]); }