public void CanInitializeFromClrGenericTypeDefinition()
{
//-- act
TypeMember genericList = typeof(List <>);
//-- assert
genericList.ClrBinding.Should().BeSameAs(typeof(List <>));
genericList.IsGenericType.Should().BeTrue();
genericList.IsGenericTypeDefinition.Should().BeTrue();
genericList.GenericTypeArguments.Should().NotBeNull();
genericList.GenericTypeArguments.Count.Should().Be(0);
genericList.GenericTypeParameters.Should().NotBeNull();
genericList.GenericTypeParameters.Count.Should().Be(1);
genericList.GenericTypeParameters[0].ClrBinding.Should().BeNull();
genericList.GenericTypeParameters[0].TypeKind.Should().Be(TypeMemberKind.GenericParameter);
genericList.IsAbstract.Should().BeFalse();
genericList.IsArray.Should().BeFalse();
genericList.IsAwaitable.Should().BeFalse();
genericList.IsCollection.Should().BeTrue();
genericList.IsNullable.Should().BeFalse();
genericList.IsValueType.Should().BeFalse();
genericList.UnderlyingType.Should().BeSameAs(genericList.GenericTypeParameters[0]);
}
public void CanCacheClrBoundTypeMembers()
{
//-- arrange
TypeMember typeInt1 = typeof(int);
TypeMember typeString1 = typeof(string);
TypeMember typeArrayOfInt1 = typeof(int[]);
TypeMember typeListOfString1 = typeof(List <string>);
//-- act
TypeMember typeInt2 = typeof(int);
TypeMember typeString2 = typeof(string);
TypeMember typeArrayOfInt2 = typeof(int[]);
TypeMember typeListOfString2 = typeof(List <string>);
//-- assert
typeInt2.Should().NotBeNull();
typeString2.Should().NotBeNull();
typeArrayOfInt2.Should().NotBeNull();
typeListOfString2.Should().NotBeNull();
typeInt2.Should().BeSameAs(typeInt1);
typeString2.Should().BeSameAs(typeString1);
typeArrayOfInt2.Should().BeSameAs(typeArrayOfInt1);
typeListOfString2.Should().BeSameAs(typeListOfString1);
typeArrayOfInt1.UnderlyingType.Should().BeSameAs(typeInt1);
typeListOfString1.UnderlyingType.Should().BeSameAs(typeString1);
typeArrayOfInt2.UnderlyingType.Should().BeSameAs(typeInt1);
typeListOfString2.UnderlyingType.Should().BeSameAs(typeString1);
}
public void CanInstantiateCompiledProducts()
{
//-- arrange
var backendUnderTest = new RoslynTypeFactoryBackend();
var compiledArtifacts = new Dictionary <TypeKey, IRuntimeTypeFactoryArtifact <object> >();
backendUnderTest.ProductsLoaded += (products) => {
foreach (var product in products)
{
compiledArtifacts.Add(product.Key, (IRuntimeTypeFactoryArtifact <object>)product.Artifact);
}
};
var key1 = new TypeKey(this.GetType(), typeof(int));
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType(), key1), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassInt");
var key2 = new TypeKey(this.GetType(), typeof(string));
var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType(), key2), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassString");
//-- act
var result = backendUnderTest.Compile(new[] { type1, type2 });
var classInt = compiledArtifacts[key1].Constructor().NewInstance();
var classString = compiledArtifacts[key2].Constructor().NewInstance();
//-- assert
result.Success.Should().BeTrue();
compiledArtifacts.Count.Should().Be(2);
classInt.GetType().FullName.Should().Be("NS1.ClassInt");
classString.GetType().FullName.Should().Be("NS2.ClassString");
}
public void CanInitializeFromClrConstructedGenericType()
{
//-- act
TypeMember listOfInt = typeof(List <int>);
//-- assert
listOfInt.ClrBinding.Should().BeSameAs(typeof(List <int>));
listOfInt.IsGenericType.Should().BeTrue();
listOfInt.IsGenericTypeDefinition.Should().BeFalse();
listOfInt.GenericTypeArguments.Should().NotBeNull();
listOfInt.GenericTypeArguments.Count.Should().Be(1);
listOfInt.GenericTypeArguments[0].ClrBinding.Should().BeSameAs(typeof(int));
listOfInt.GenericTypeParameters.Should().NotBeNull();
listOfInt.GenericTypeParameters.Count.Should().Be(0);
listOfInt.IsAbstract.Should().BeFalse();
listOfInt.IsArray.Should().BeFalse();
listOfInt.IsAwaitable.Should().BeFalse();
listOfInt.IsCollection.Should().BeTrue();
listOfInt.IsNullable.Should().BeFalse();
listOfInt.IsValueType.Should().BeFalse();
listOfInt.UnderlyingType.Should().BeSameAs(listOfInt.GenericTypeArguments[0]);
}
public void OneGroupIterationSystem([Values] CodeGenMode mode)
{
SetupTestGraph(mode, g =>
{
ComponentQueryDeclarationModel query = GraphModel.CreateComponentQuery("g1");
TypeHandle positionType = typeof(Translation).GenerateTypeHandle(Stencil);
query.AddComponent(Stencil, positionType, ComponentDefinitionFlags.None);
IVariableModel queryInstance = GraphModel.CreateVariableNode(query, Vector2.zero);
OnUpdateEntitiesNodeModel onUpdateModel = GraphModel.CreateNode <OnUpdateEntitiesNodeModel>("update", Vector2.zero);
GraphModel.CreateEdge(onUpdateModel.InstancePort, queryInstance.OutputPort);
SetPropertyGroupNodeModel set = onUpdateModel.CreateStackedNode <SetPropertyGroupNodeModel>("set");
var member = new TypeMember(TypeHandle.Float, new List <string> {
nameof(Translation.Value), nameof(Translation.Value.x)
});
set.AddMember(member);
IVariableModel posComponent = GraphModel.CreateVariableNode(onUpdateModel.FunctionParameterModels.Single(p => p.DataType == positionType), Vector2.zero);
GraphModel.CreateEdge(set.InstancePort, posComponent.OutputPort);
((FloatConstantModel)set.InputConstantsById[member.GetId()]).value = 2f;
},
(manager, entityIndex, e) => manager.AddComponentData(e, new Translation {
Value = { x = entityIndex }
}),
(manager, entityIndex, e) => Assert.That(manager.GetComponentData <Translation>(e).Value.x, Is.EqualTo(2f)));
}
public void CanCompileAssembly()
{
//-- arrange
var backendUnderTest = new RoslynTypeFactoryBackend();
var key1 = new TypeKey(this.GetType(), typeof(int), typeof(int), typeof(int), typeof(int), 1, 2, 3);
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType(), key1));
type1.Namespace = "NS1";
type1.Visibility = MemberVisibility.Public;
type1.TypeKind = TypeMemberKind.Class;
type1.Name = "ClassOne";
//-- act
var result = backendUnderTest.Compile(new[] { type1 });
//-- assert
result.Success.Should().BeTrue();
result.Succeeded.Count.Should().Be(1);
result.Succeeded[0].Type.Should().BeSameAs(type1);
result.Failed.Count.Should().Be(0);
}
public void SimpleEnum()
{
//-- arrange
var enumMember = new TypeMember();
enumMember.Namespace = "SyntaxGeneratorTests";
enumMember.Name = "TestEnum";
enumMember.Members.Add(new EnumMember()
{
Name = "First"
});
enumMember.Members.Add(new EnumMember()
{
Name = "Second"
});
enumMember.Members.Add(new EnumMember()
{
Name = "Third"
});
var emitter = new EnumSyntaxEmitter(enumMember);
//-- act
var syntax = emitter.EmitSyntax();
//-- assert
syntax.Should().BeEquivalentToCode(
"public enum TestEnum { First, Second, Third }"
);
}
void NormalizeVisibility(TypeMember node)
{
if (!node.IsVisibilitySet)
{
node.Modifiers |= TypeMemberModifiers.Public;
}
}
private bool IsConflictingOverload(TypeMember member, TypeMember existingMember)
{
return(AreParametersTheSame(existingMember, member) &&
!AreDifferentInterfaceMembers((IExplicitMember)existingMember, (IExplicitMember)member) &&
!AreDifferentConversionOperators(existingMember, member) &&
IsGenericityTheSame(existingMember, member));
}
protected void CheckMember(List <TypeMember> list, TypeMember member)
{
switch (member.NodeType)
{
case NodeType.StatementTypeMember:
break;
case NodeType.Constructor:
case NodeType.Method:
{
CheckOverloadableMember(list, member);
CheckLikelyTypoInTypeMemberName(member);
break;
}
case NodeType.Property:
{
CheckOverloadableMember(list, member);
break;
}
default:
{
CheckNonOverloadableMember(list, member);
break;
}
}
}
protected void CheckNonOverloadableMember(List <TypeMember> existing, TypeMember member)
{
if (existing.Count > 0)
{
MemberNameConflict(member);
}
}
public ClrTypeReader(Type clrType, TypeMember typeMember, ImperativeCodeModel codeModel, int distance)
{
_clrType = clrType;
_typeMember = typeMember;
_codeModel = codeModel;
_distance = distance;
}
protected void WarnIfProtectedMemberInSealedClass(TypeMember member)
{
if (member.IsProtected && !member.IsSynthetic && !member.IsOverride && member.DeclaringType.IsFinal)
{
Warnings.Add(CompilerWarningFactory.NewProtectedMemberInSealedType(member));
}
}
public void MakeGenericTypeOfBoundTypesResultsInBoundType()
{
//-- arrange
TypeMember typeInt = typeof(int);
TypeMember typeString = typeof(string);
TypeMember typeIDictionaryOpen = typeof(IDictionary <,>);
//-- act
TypeMember constructedType = typeIDictionaryOpen.MakeGenericType(typeInt, typeString);
//-- assert
constructedType.ClrBinding.Should().NotBeNull();
constructedType.ClrBinding.Should().BeSameAs(typeof(IDictionary <int, string>));
constructedType.Should().NotBeNull();
constructedType.IsGenericType.Should().BeTrue();
constructedType.IsGenericTypeDefinition.Should().BeFalse();
constructedType.GenericTypeDefinition.Should().BeSameAs(typeIDictionaryOpen);
constructedType.GenericTypeArguments.Count.Should().Be(2);
constructedType.GenericTypeArguments[0].Should().BeSameAs(typeInt);
constructedType.GenericTypeArguments[1].Should().BeSameAs(typeString);
}
//returns true if a stub has been created, false otherwise.
//TODO: add entity argument to the method to not need return type?
bool AbstractMemberNotImplemented(ClassDefinition node, TypeReference baseTypeRef, IMember member)
{
if (IsValueType(node))
{
Error(CompilerErrorFactory.ValueTypeCantHaveAbstractMember(baseTypeRef, GetType(node), member));
return(false);
}
if (!node.IsAbstract)
{
//BEHAVIOR >= 0.7.7: (see BOO-789 for details)
//create a stub for this not implemented member
//it will raise a NotImplementedException if called at runtime
TypeMember m = CodeBuilder.CreateStub(node, member);
CompilerWarning warning = null;
if (null != m)
{
warning = CompilerWarningFactory.AbstractMemberNotImplementedStubCreated(baseTypeRef, GetType(node), member);
if (m.NodeType != NodeType.Property || null == node.Members[m.Name])
{
AddStub(node, m);
}
}
else
{
warning = CompilerWarningFactory.AbstractMemberNotImplemented(baseTypeRef, GetType(node), member);
_newAbstractClasses.AddUnique(node);
}
Warnings.Add(warning);
return(null != m);
}
return(false);
}
void WriteModifiers(TypeMember member)
{
WriteIndented();
if (member.IsPublic)
{
Write("public ");
}
else if (member.IsProtected)
{
Write("protected ");
}
else if (member.IsPrivate)
{
Write("private ");
}
else if (member.IsInternal)
{
Write("internal ");
}
if (member.IsStatic)
{
Write("static ");
}
if (member.IsFinal)
{
Write("final ");
}
if (member.IsTransient)
{
Write("transient ");
}
}
void CantBeMarkedTransient(TypeMember member)
{
if (member.IsTransient)
{
Error(CompilerErrorFactory.CantBeMarkedTransient(member));
}
}
void CantBeMarkedPartial(TypeMember member)
{
if (member.IsPartial)
{
Error(CompilerErrorFactory.CantBeMarkedPartial(member));
}
}
void CantBeMarkedStatic(TypeMember member)
{
if (member.IsStatic)
{
Error(CompilerErrorFactory.CantBeMarkedStatic(member));
}
}
void CantBeMarkedAbstract(TypeMember member)
{
if (member.IsAbstract)
{
Error(CompilerErrorFactory.CantBeMarkedAbstract(member));
}
}
public void Visit_ConstructorBodyStatementsIncluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var constructor1 = new ConstructorMember(MemberVisibility.Public, MemberModifier.None, "ClassOne", new MethodSignature());
var variable1 = new LocalVariable {
Name = "x", Type = typeof(TimeSpan)
};
constructor1.Body = new BlockStatement(
new VariableDeclarationStatement {
Variable = variable1
}
);
type1.Members.Add(constructor1);
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, typeof(TimeSpan)
});
}
public void Visit_MethodSignatureTypesIncluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
type1.Members.Add(new MethodMember(MemberVisibility.Public, MemberModifier.None, "M1", new MethodSignature(
new[] { new MethodParameter("x", 1, typeof(int)), new MethodParameter("y", 2, typeof(string)) },
returnValue: null,
isAsync: false
)));
type1.Members.Add(new MethodMember(MemberVisibility.Public, MemberModifier.Static, "M2", new MethodSignature(
new MethodParameter[0],
returnValue: new MethodParameter(null, -1, typeof(TimeSpan)),
isAsync: false
)));
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, typeof(int), typeof(string), typeof(TimeSpan)
});
}
public void Visit_EventDelegateTypesInluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassTwo");
type1.Members.Add(new EventMember(
MemberVisibility.Public, MemberModifier.None, typeof(Action <DateTime>), "E1"));
type1.Members.Add(new EventMember(
MemberVisibility.Public, MemberModifier.Static, ((TypeMember)typeof(Action <>)).MakeGenericType(type2), "E2"));
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, typeof(Action <>), typeof(DateTime), type2
});
}
public TypeMember Reify(TypeMember node)
{
Visit(node);
var method = node as Method;
if (method != null)
{
ReifyMethod(method);
return(node);
}
var @event = node as Event;
if (@event != null)
{
ReifyEvent(@event);
return(node);
}
var property = node as Property;
if (property != null)
{
ReifyProperty(property);
}
return(node);
}
public void FieldWithInitializer()
{
//-- arrange
var classMember = new TypeMember(MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var fieldMember = new FieldMember(classMember, MemberVisibility.Private, MemberModifier.None, typeof(int), "_number")
{
IsReadOnly = true,
Initializer = new ConstantExpression {
Value = 123
}
};
classMember.Members.Add(fieldMember);
var emitter = new ClassSyntaxEmitter(classMember);
//-- act
var syntax = emitter.EmitSyntax();
//-- assert
syntax.Should().BeEquivalentToCode(@"
public class ClassOne
{
private readonly int _number = 123;
}
");
}
//TODO: add detection & resolution of duplicate names
public static TypeMember WebApiController(TypeMember middlewareType, WebApiMetadata api) =>
PUBLIC.CLASS(ID(api.InterfaceType.Name.TrimPrefixFragment("I"), "Controller"), () => {
EXTENDS <Controller>();
ATTRIBUTE <RouteAttribute>("api/[controller]");
PRIVATE.READONLY.FIELD(api.InterfaceType, "_service", out var @serviceField);
PUBLIC.CONSTRUCTOR(() => {
PARAMETER(api.InterfaceType, "service", out var @service);
@serviceField.ASSIGN(@service);
});
api.ApiMethods.ForEach(apiMethod => {
var requestClass = DataTransferObjectGenerator.MethodInvocation(apiMethod);
PUBLIC.ASYNC.FUNCTION <Task <IActionResult> >(apiMethod.Name, () => {
ATTRIBUTE(middlewareType);
ATTRIBUTE <HttpPostAttribute>(apiMethod.Name.ToString(CasingStyle.Camel));
PARAMETER(requestClass, "requestData", out MethodParameter @requestData, () => {
ATTRIBUTE <FromBodyAttribute>();
});
LOCAL(apiMethod.ReturnType.GenericArguments[0], "resultValue", out LocalVariable resultValueLocal);
resultValueLocal.ASSIGN(
AWAIT(THIS.DOT(@serviceField).DOT(apiMethod).INVOKE(() => {
apiMethod.Signature.Parameters.ForEach(p => ARGUMENT(@requestData.DOT(p.Name.ToString(CasingStyle.Pascal))));
}))
);
DO.RETURN(THIS.DOT("Json").INVOKE(resultValueLocal));
});
});
private bool IsCorrectExplicitMemberImplOrNoExplicitMemberAtAll(TypeMember member, IMember entity)
{
ExplicitMemberInfo info = ((IExplicitMember)member).ExplicitInfo;
return(info == null ||
entity.DeclaringType == GetType(info.InterfaceType));
}
override public void OnExplicitMemberInfo(ExplicitMemberInfo node)
{
TypeMember member = (TypeMember)node.ParentNode;
CheckExplicitMemberValidity((IExplicitMember)member);
member.Visibility = TypeMemberModifiers.Private;
}
public void TestCriteriaSearcher()
{
var selectedItem = m_Sources.Find(BinaryOperatorKind.Equals.ToString());
var selectedComponent = TypeHandle.Unknown;
var selectedMember = new TypeMember();
var selectedOperator = BinaryOperatorKind.Xor;
void Callback(TypeHandle handle, TypeMember member, BinaryOperatorKind kind)
{
selectedComponent = handle;
selectedMember = member;
selectedOperator = kind;
}
var onItemSelected = typeof(EcsSearcherServices).GetMethod("OnItemSelected", BindingFlags.Static | BindingFlags.NonPublic);
onItemSelected?.Invoke(null, new object[]
{
selectedItem,
(Action <TypeHandle, TypeMember, BinaryOperatorKind>)Callback
});
var dummyComponent = typeof(DummyTestComponent).GenerateTypeHandle(m_Stencil);
Assert.AreEqual(dummyComponent, selectedComponent);
Assert.AreEqual(selectedOperator, BinaryOperatorKind.Equals);
Assert.AreEqual(selectedMember.Type, typeof(float).GenerateTypeHandle(m_Stencil));
Assert.That(selectedMember.Path, Is.EqualTo(new List <string> {
"Value", "x"
}));
}
public void Visit_GenericTypeDefinitionsAndArgumentsIncluded()
{
//-- arrange
var type1 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS1", MemberVisibility.Public, TypeMemberKind.Class, "ClassOne");
var type2 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS2", MemberVisibility.Public, TypeMemberKind.Class, "ClassTwo");
var type3 = new TypeMember(new TypeGeneratorInfo(this.GetType()), "NS3", MemberVisibility.Public, TypeMemberKind.Class, "ClassThree");
type1.Members.Add(new PropertyMember(
type1, MemberVisibility.Public, MemberModifier.None, ((TypeMember)typeof(IList <>)).MakeGenericType(type2), "Twos"));
type1.Members.Add(new PropertyMember(
type1, MemberVisibility.Public, MemberModifier.Static, ((TypeMember)typeof(IDictionary <,>)).MakeGenericType(type2, type3), "ThreeByTwo"));
var foundTypes = new HashSet <TypeMember>();
var visitorUnderTest = new TypeReferenceMemberVisitor(foundTypes);
//-- act
type1.AcceptVisitor(visitorUnderTest);
//-- assert
foundTypes.Should().BeEquivalentTo(new TypeMember[] {
type1, typeof(IList <>), typeof(IDictionary <,>), type2, type3
});
}
public Guid AddTypeMember(AddTypeMemberCommand command)
{
ThrowError.Against<ArgumentException>(string.IsNullOrEmpty(command.Name), String.Format(ErrorMessage.IsRequired,"Tên"));
ThrowError.Against<ArgumentException>(_typeMemberService.Query(t => t.Name.ToUpper().Trim() == command.Name.ToUpper().Trim()).Select().Any(), String.Format(ErrorMessage.Exists, "Tên"));
var count = _typeMemberService.Query(t => ((t.ScoresFrom < command.ScoresFrom && command.ScoresFrom < t.ScoresTo) || (t.ScoresFrom < command.ScoresTo && command.ScoresTo < t.ScoresTo) || (command.ScoresFrom < t.ScoresFrom && t.ScoresFrom < command.ScoresTo) || (command.ScoresFrom < t.ScoresTo && t.ScoresTo < command.ScoresTo) || (command.ScoresFrom == t.ScoresFrom && command.ScoresTo == t.ScoresTo))).Select().Count();
ThrowError.Against<ArgumentException>(count > 0, String.Format(ErrorMessage.IsNotTypemMember));
var typeMember = new TypeMember()
{
Name = command.Name,
PercentDownPayment = command.PercentDownPayment,
ScoresFrom = command.ScoresFrom,
ScoresTo = command.ScoresTo,
TypeMemberId = Guid.NewGuid()
};
_typeMemberService.Insert(typeMember);
_unitOfWork.SaveChanges();
return typeMember.TypeMemberId;
}
private void DiscoverMembers()
{
Type type = GetType();
MemberInfo[] memberInfos = type.FindMembers(MemberTypes.Field | MemberTypes.Property,
BindingFlags.Instance | BindingFlags.Public, FilterMember, null);
for (int i = 0; i < memberInfos.Length; i++) {
MemberInfo member = memberInfos[i];
if (Attribute.IsDefined(member, typeof(TagContentAttribute))) {
if (contentMember != null)
throw new ArgumentException(String.Format("Type {0} has more than one content member.", type));
contentMember = new TypeMember(this, member, null, false);
} else {
TagAttributeAttribute attribute =
(TagAttributeAttribute)Attribute.GetCustomAttribute(member, typeof(TagAttributeAttribute));
string attributeName = attribute.Name;
if (String.IsNullOrEmpty(attributeName))
attributeName = member.Name;
if (attributes.ContainsKey(attributeName))
throw new ArgumentException(String.Format("Type {0} has more than one attribute {1}", type, attributeName));
attributes[attributeName] = new TypeMember(this, member, attributeName, attribute.IsRequired);
}
}
}
public TypeMemberStatement(TypeMember typeMember) : base(typeMember.LexicalInfo)
{
TypeMember = typeMember;
}
