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; }