//-----------------------------------------------------------------------------------------------------------------------------------------------------
public NewStructExpression(IOperand[] constructorArguments = null)
{
m_StatementScope = StatementScope.Current;
m_StructType = TypeTemplate.Resolve <TStruct>();
m_ConstructorArguments = (constructorArguments ?? new IOperand[0]);
if (m_ConstructorArguments.Length > 0)
{
var argumentTypes = m_ConstructorArguments.Select(arg => arg.OperandType).ToArray();
m_Constructor = m_StructType.GetConstructor(argumentTypes);
if (m_Constructor == null)
{
throw new ArgumentException("Could not find constructor with specified argument types.");
}
foreach (var argument in m_ConstructorArguments.Reverse())
{
m_StatementScope.Consume(argument);
}
}
m_StatementScope.RegisterExpressionStatement(this);
}
internal static string GenerateRecord(TypeTemplate template, TypeTemplate[] templates)
{
var cls = template.ClassName.Split('.');
var nameSpace = string.Join(".", cls.Take(cls.Length - 1));
var className = cls.Last();
var rt = new StringBuilder();
rt.AppendLine("using System;\r\nusing Esiur.Resource;\r\nusing Esiur.Core;\r\nusing Esiur.Data;\r\nusing Esiur.Net.IIP;");
rt.AppendLine($"namespace { nameSpace} {{");
if (template.Annotation != null)
{
rt.AppendLine($"[Annotation({ToLiteral(template.Annotation)})]");
}
rt.AppendLine($"[Public] public class {className} : IRecord {{");
foreach (var p in template.Properties)
{
var ptTypeName = GetTypeName(p.ValueType, templates);
rt.AppendLine($"public {ptTypeName} {p.Name} {{ get; set; }}");
rt.AppendLine();
}
rt.AppendLine("\r\n}\r\n}");
return(rt.ToString());
}
internal static string GenerateEnum(TypeTemplate template, TypeTemplate[] templates)
{
var cls = template.ClassName.Split('.');
var nameSpace = string.Join(".", cls.Take(cls.Length - 1));
var className = cls.Last();
var rt = new StringBuilder();
rt.AppendLine("using System;\r\nusing Esiur.Resource;\r\nusing Esiur.Core;\r\nusing Esiur.Data;\r\nusing Esiur.Net.IIP;");
rt.AppendLine($"namespace { nameSpace} {{");
if (template.Annotation != null)
{
rt.AppendLine($"[Annotation({ToLiteral(template.Annotation)})]");
}
rt.AppendLine($"[Public] public enum {className} {{");
rt.AppendLine(String.Join(",\r\n", template.Constants.Select(x => $"{x.Name}={x.Value}")));
rt.AppendLine("\r\n}\r\n}");
return(rt.ToString());
}
public MemberTemplate(TypeTemplate template, byte index, string name, bool inherited)
{
Template = template;
Index = index;
Name = name;
Inherited = inherited;
}
public EventTemplate(TypeTemplate template, byte index, string name, bool inherited, RepresentationType argumentType, string annotation = null, bool listenable = false)
: base(template, index, name, inherited)
{
this.Annotation = annotation;
this.Listenable = listenable;
this.ArgumentType = argumentType;
}
public void Emit(ILGenerator il, IOperand <int> lengthOperand)
{
lengthOperand.EmitTarget(il);
lengthOperand.EmitLoad(il);
il.Emit(OpCodes.Newarr, TypeTemplate.Resolve <TElement>());
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
public override void DefineMemberBody()
{
var typedGetterDefinition = (GetterBodyDefinition as Action <IHappilMethodBody <T>, HappilArgument <TIndex1> >);
var typedSetterDefinition = (SetterBodyDefinition as Action <IVoidHappilMethodBody, HappilArgument <TIndex1>, HappilArgument <T> >);
using (TypeTemplate.CreateScope(
typeof(TypeTemplate.TIndex1), OwnerProperty.Declaration.GetIndexParameters()[0].ParameterType))
{
if (typedGetterDefinition != null)
{
using ((GetterMethod as IHappilMember).CreateTypeTemplateScope())
{
using (GetterMethod.CreateBodyScope())
{
typedGetterDefinition(GetterMethod.GetMethodBody <T>(), new HappilArgument <TIndex1>(GetterMethod, 1));
}
}
}
if (typedSetterDefinition != null)
{
using ((SetterMethod as IHappilMember).CreateTypeTemplateScope())
{
using (SetterMethod.CreateBodyScope())
{
typedSetterDefinition(SetterMethod, new HappilArgument <TIndex1>(SetterMethod, 1), new HappilArgument <T>(SetterMethod, 2));
}
}
}
}
}
public void Emit(ILGenerator il, IOperand <T> left, IOperand <Type> right)
{
var typeConstant = (right as Constant <Type>);
if (object.ReferenceEquals(typeConstant, null))
{
throw new NotSupportedException("Cast type must be a constant type known in advance.");
}
var fromType = left.OperandType;
var castType = TypeTemplate.Resolve(typeConstant.Value);
left.EmitTarget(il);
left.EmitLoad(il);
if (fromType.IsValueType)
{
il.Emit(OpCodes.Box, fromType);
}
else
{
il.Emit(OpCodes.Isinst, castType);
if (castType.IsNullableValueType())
{
il.Emit(OpCodes.Unbox_Any, castType);
}
}
}
private void WriteReader(ClassTemplate classTemplate, ModelTransferObject model)
{
IOptions modelOptions = this.Options.Get(model);
TypeTemplate objectType = Code.Type(model.Name, model.Namespace);
if (model.Namespace != classTemplate.Namespace.Name && model.Namespace != null)
{
classTemplate.AddUsing(model.Namespace);
}
classTemplate.WithUsing("Newtonsoft.Json")
//.WithUsing("Newtonsoft.Json.Linq")
.WithUsing("System.IO");
classTemplate.AddMethod("Load", objectType)
.FormatName(modelOptions)
.WithParameter(Code.Type("string"), "fileName")
.Static()
.Code.AddLine(Code.Return(Code.Method("Parse", Code.Local("File").Method("ReadAllText", Code.Local("fileName")))));
classTemplate.AddMethod("Parse", objectType)
.FormatName(modelOptions)
.WithParameter(Code.Type("string"), "json")
.Static()
.Code.AddLine(Code.Return(Code.Local("JsonConvert").GenericMethod("DeserializeObject", objectType, Code.Local("json"))));
}
private void CreateTypeFiles()
{
foreach (var solution in StepInput.SDProject.Solutions.Values)
{
var sdRepository = solution.Repositories.SingleOrDefault(r => r.TargetFx.Identifier == StepInput.CurrentTargetFx.Identifier);
if (sdRepository != null)
{
foreach (var sdNamespace in sdRepository.GetAllNamespaces())
{
foreach (var sdType in sdNamespace.Types)
{
ExecuteOnStepMessage(string.Format("{0}: {1}", StepInput.ChmStrings.CreateType, sdType.Name));
var typeHtmlFile = Path.Combine(StepInput.TmpPath, sdType.Guid + ".html");
var template = new TypeTemplate {
SDType = sdType, SDRepository = sdRepository
};
if (!sdType.IsClassDiagramEmpty())
{
sdType.GetClassDiagram().ToPng(Path.Combine(StepInput.TmpPath, "diagrams", sdType.Guid + ".png"));
}
File.WriteAllText(typeHtmlFile, template.TransformText());
}
}
}
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteParentFieldInitialization()
{
using (TypeTemplate.CreateScope <TypeTemplate.TField>(m_Parent.ClosureClass.TypeBuilder))
{
m_ParentField.AsOperand <TypeTemplate.TField>(m_ClosureInstanceReference).Assign(m_Parent.m_ClosureInstanceReference.CastTo <TypeTemplate.TField>());
}
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
internal override IDisposable CreateTypeTemplateScope()
{
var reflectionCache = DelegateShortcuts.GetReflectionCache(m_Declaration.EventHandlerType);
return(TypeTemplate.CreateScope(
typeof(TypeTemplate.TEventHandler), m_Declaration.EventHandlerType,
typeof(TypeTemplate.TEventArgs), reflectionCache.Invoke.GetParameters()[1].ParameterType));
}
public FunctionTemplate(TypeTemplate template, byte index, string name, bool inherited, ArgumentTemplate[] arguments, RepresentationType returnType, string annotation = null)
: base(template, index, name, inherited)
{
//this.IsVoid = isVoid;
this.Arguments = arguments;
this.ReturnType = returnType;
this.Annotation = annotation;
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public HappilOperand <TCast> CastTo <TCast>()
{
return(new HappilBinaryExpression <T, Type, TCast>(
OwnerMethod,
@operator: new BinaryOperators.OperatorCastOrThrow <T>(),
left: this,
right: new HappilConstant <Type>(TypeTemplate.Resolve <TCast>())));
}
public void TypeTemplateTest()
{
var type = typeof(IDictionary <string, Func <object, DateTime, bool, Task <Guid> > >);
var template = new TypeTemplate(type);
var name = template.ToString();
Assert.Equal("System.Collections.Generic.IDictionary<System.String,System.Func<System.Object,System.DateTime,System.Boolean,System.Threading.Tasks.Task<System.Guid>>>", name);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected override Type[] BuildTemplateActualTypePairs()
{
var pairs = new Type[m_ArgumentTypes.Length * 2];
TypeTemplate.BuildArgumentsTypePairs(m_ArgumentTypes, pairs, arrayStartIndex: 0);
return(pairs);
}
protected override void BuildArguments(TypeTemplate <Employee> config)
{
config
.AddAllProperties().Except("DontLogMe", "Reports")
.AddArgument(x => x.Company.Id)
.AddArgument(x => x.Id)
.AddArgument(x => x.SomeDate ?? DateTime.MinValue);
}
public void Write(GenericTypeTemplate template, IOutputCache output)
{
TypeTemplate keyType = template.Types.First();
TypeTemplate valueType = template.Types.Second();
if (keyType.Name is "string" or "number")
{
output.Add($"{{ [key: {keyType.Name}]: {valueType.Name}; }}");
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteReturnValueCheck(MethodDecorationBuilder decoration)
{
decoration.OnReturnValue((w, retVal) => {
using (TypeTemplate.CreateScope <TypeTemplate.TArgument>(m_ParameterInfo.ParameterType))
{
WriteArgumentOrCollectionItemCheck(w, retVal.CastTo <TypeTemplate.TArgument>(), isOutput: true);
}
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IDisposable CreateTypeTemplateScope()
{
if (m_TemplateActualTypePairs == null)
{
m_TemplateActualTypePairs = BuildTemplateActualTypePairs();
}
return(TypeTemplate.CreateScope(m_TemplateActualTypePairs));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private Delegate CreateFactoryMethodDelegate(MethodInfo factoryMethod)
{
var parameters = factoryMethod.GetParameters();
var openDelegateType = s_DelegatePrototypesByArgumentCount[parameters.Length];
var delegateTypeParameters = parameters.Select(p => TypeTemplate.Resolve(p.ParameterType)).Concat(new[] { factoryMethod.ReturnType });
var closedDelegateType = openDelegateType.MakeGenericType(delegateTypeParameters.ToArray());
return(Delegate.CreateDelegate(closedDelegateType, factoryMethod));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
//internal void MakeInstanceMethod()
//{
// var anonymousMethodFactory = (m_MethodFactory as AnonymousMethodFactory);
// if ( anonymousMethodFactory == null )
// {
// throw new InvalidOperationException("Method modifiers are mutable only for anonymous methods.");
// }
// anonymousMethodFactory.ChangeMethodAttributes(isStatic: false);
//}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
//internal void HoistInClosure(ClosureDefinition closure)
//{
// var anonymousMethodFactory = (m_MethodFactory as AnonymousMethodFactory);
// if ( anonymousMethodFactory == null )
// {
// throw new InvalidOperationException("Only anonymous method can be moved to a closure class.");
// }
// base.OwnerClass.MoveMember(this, destination: closure.ClosureClass);
// base.OwnerClass = closure.ClosureClass;
// anonymousMethodFactory.MethodMovedToClosure(closure.ClosureClass);
// m_Writers.Clear();
// m_Closure = closure;
//}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
internal override IDisposable CreateTypeTemplateScope()
{
if (m_CachedTemplateTypePairs == null)
{
m_CachedTemplateTypePairs = Signature.BuildTemplateTypePairs();
}
return(TypeTemplate.CreateScope(m_CachedTemplateTypePairs));
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteCaptureFieldInitialization(OperandCapture capture)
{
using (TypeTemplate.CreateScope <TypeTemplate.TField>(capture.OperandType))
{
if (capture.SourceOperand.ShouldInitializeHoistedField)
{
capture.HoistedField.AsOperand <TypeTemplate.TField>(m_ClosureInstanceReference).Assign(capture.SourceOperand.CastTo <TypeTemplate.TField>());
}
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
private void WriteArgumentInputCheck(MethodDecorationBuilder decoration)
{
decoration.OnBefore(w => {
using (TypeTemplate.CreateScope <TypeTemplate.TArgument>(m_ParameterInfo.ParameterType))
{
var argument = w.Argument <TypeTemplate.TArgument>(m_ParameterInfo.Position + 1);
WriteArgumentOrCollectionItemCheck(w, argument, isOutput: false);
}
});
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
protected AnonymousDelegateOperand(ClassType ownerClass, Type[] argumentTypes, Type returnType)
{
m_OwnerClass = ownerClass;
m_HomeScopeBlock = StatementScope.Current.StatementBlock;
m_Statements = new StatementBlock();
m_Signature = new MethodSignature(
isStatic: true,
isPublic: false,
argumentTypes: argumentTypes.Select(TypeTemplate.Resolve).ToArray(),
returnType: returnType != null ? TypeTemplate.Resolve(returnType) : null);
}
//-----------------------------------------------------------------------------------------------------------------------------------------------------
public IHappilOperand <TObject> New <TObject>(params IHappilOperand[] constructorArguments)
{
if (TypeTemplate.Resolve <TObject>().IsValueType)
{
return(new NewStructExpression <TObject>(constructorArguments));
}
else
{
return(new NewObjectExpression <TObject>(constructorArguments));
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------
protected override IDisposable CreateTemplateScope(MethodInfo method)
{
var parameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
var templateTypePairs = new Type[2 * (1 + parameterTypes.Length)];
templateTypePairs[0] = typeof(TypeTemplate.TReturn);
templateTypePairs[1] = method.ReturnType;
TypeTemplate.BuildArgumentsTypePairs(parameterTypes, templateTypePairs, arrayStartIndex: 2);
return(TypeTemplate.CreateScope(templateTypePairs));
}
public void Should_build_argument_from_property_with_method_Call()
{
var typeTemplate = new TypeTemplate <Employee>();
typeTemplate.AddArgument(x => x.Company.AsJson());
var typeTemplateModel = typeTemplate.GetModel();
typeTemplateModel.Arguments.Single().Name.Should().Be("CompanyAsJson");
typeTemplateModel.Arguments.Single().Assignment.Should().Be("$this.Company.AsJson()");
}
public void Should_build_argument_from_property_with_datetime_coaless()
{
var typeTemplate = new TypeTemplate <Employee>();
typeTemplate.AddArgument(x => (x.SomeDate ?? DateTime.MinValue));
var typeTemplateModel = typeTemplate.GetModel();
typeTemplateModel.Arguments.Single().Name.Should().Be("SomeDate");
typeTemplateModel.Arguments.Single().Assignment.Should().Be("$this.SomeDate ?? DateTime.MinValue");
}
public void Should_build_argument_from_property_with_null_coaless()
{
var typeTemplate = new TypeTemplate <Employee>();
typeTemplate.AddArgument(x => (x.Id ?? ""));
var typeTemplateModel = typeTemplate.GetModel();
typeTemplateModel.Arguments.Single().Assignment.Should().Be("Id");
typeTemplateModel.Arguments.Single().Assignment.Should().Be("$this.Id ?? \"\"");
}
