public override ExpressionSyntax GetCachedValue(string key, ExpressionSyntax value, TypeHandle modelReturnType, params IdentifierNameSyntax[] attributes) { key = key.Replace(".", "_"); if (m_Constants.TryGetValue(key, out var node)) { return(node); } string variableName = MakeUniqueName(key); var fieldDeclarationSyntax = RoslynBuilder.DeclareField( modelReturnType.Resolve(IterationContext.Stencil), variableName, AccessibilityFlags.Public); if (attributes.Any()) { fieldDeclarationSyntax = fieldDeclarationSyntax.AddAttributeLists(AttributeList(SeparatedList(attributes.Select(Attribute)))); } m_MemberDeclarations.Add(fieldDeclarationSyntax); IdentifierNameSyntax variable = IdentifierName(variableName); m_JobInitializers.Add(AssignmentExpression( SyntaxKind.SimpleAssignmentExpression, variable, value )); m_Constants.Add(key, variable); return(variable); }
public override string GetComponentVariableName(IIteratorStackModel query, TypeHandle componentVariableType) { // TODO forward to parent if necessary return(query == IterationContext.Query ? IterationContext.GetComponentDataName(componentVariableType.Resolve(IterationContext.Stencil)) : Parent.GetComponentVariableName(query, componentVariableType)); }
public override ExpressionSyntax GetCachedValue(string key, ExpressionSyntax value, TypeHandle type, params IdentifierNameSyntax[] attributes) { var constant = base.GetCachedValue(key, value, type, attributes); // Use the same identifier as the parentJob. This avoid things like myCoroutine.FixedTime0 = FixedTime var variableName = constant is IdentifierNameSyntax ins ? ins.Identifier.Text : key.Replace(".", "_"); var found = m_Parameters.FirstOrDefault(p => p.Value.Identifier.Text.Equals(variableName)); if (found.Value != null) { return(IdentifierName(found.Value.Identifier)); } var param = Parameter(Identifier(variableName)) .WithType(TypeSystem.BuildTypeSyntax(type.Resolve(IterationContext.Stencil))); if (attributes.Any()) { param.AddAttributeLists(AttributeList(SeparatedList(attributes.Select(Attribute)))); } m_Parameters.Add(Argument(constant), param); return(IdentifierName(param.Identifier)); }
public virtual List <SearcherDatabase> GetTypeMembersSearcherDatabases(TypeHandle typeHandle) { if (typeHandle.GraphModelReference) { return(new List <SearcherDatabase> { new GraphElementSearcherDatabase(m_Stencil) .AddGraphAssetMembers(typeHandle.GraphModelReference) .Build() }); } // TODO : Need to be handled by TypeHandle.Resolve Type type = typeHandle == TypeHandle.ThisType ? m_Stencil.GetThisType().Resolve(m_Stencil) : typeHandle.Resolve(m_Stencil); return(new List <SearcherDatabase> { new GraphElementSearcherDatabase(m_Stencil) .AddMembers( new[] { type }, MemberFlags.Field | MemberFlags.Method | MemberFlags.Property | MemberFlags.Extension, BindingFlags.Instance | BindingFlags.Public ) .Build() }); }
public static Type InferReturnType(Stencil stencil, MethodBase methodBase, Type[] genericTypes, TypeHandle[] solvedTypeArguments, Type dataType) { Type returnType = methodBase.GetReturnType(); if (returnType == typeof(void) || !returnType.ContainsGenericParameters) { return(null); } Type genericType = genericTypes.SingleOrDefault(); TypeHandle solvedType = solvedTypeArguments.SingleOrDefault(); Type newOutputType = null; if (returnType == genericType) // T F<T>() == T { newOutputType = solvedType.Resolve(stencil); } else if (returnType.IsGenericType) // List<T> F<T>() { if (returnType.IsConstructedGenericType && returnType.GenericTypeArguments[0] == genericType || // class C<T> { List<T> F() } !returnType.IsConstructedGenericType && returnType.GetGenericArguments()[0] == genericType) // class C { List<T> F<T>() } { newOutputType = dataType.GetGenericTypeDefinition().MakeGenericType(solvedType.Resolve(stencil)); } } return(newOutputType); }
public void Test_TypeHandleDeserializationOfRegularType() { //Arrange TypeHandle th = typeof(A).GenerateTypeHandle(m_TypeSerializer); //Act Type deserializedTypeHandle = th.Resolve(m_TypeSerializer); //Assert Assert.That(deserializedTypeHandle, Is.EqualTo(typeof(A))); }
public void Test_TypeHandleDeserializationOfRenamedType() { var typeSerializer = new CSharpTypeSerializer(new Dictionary <string, string> { { typeof(A).AssemblyQualifiedName, typeof(B).AssemblyQualifiedName } }); TypeHandle th = typeof(A).GenerateTypeHandle(typeSerializer); Type deserializedTypeHandle = th.Resolve(typeSerializer); Assert.That(deserializedTypeHandle, Is.EqualTo(typeof(B))); }
public void Test_TypeHandle_WithNestedType_Resolve_ChangedAssembly_WithMovedFromAttribute() { var typeStr = typeof(EnclosingType.InnerTypeUnchanged).AssemblyQualifiedName; var originalTypeStr = typeStr? .Replace("NewNamespace", "OldNamespace") .Replace("GraphTools.", "OldAssemblyName."); var typeHandle = new TypeHandle(originalTypeStr); var resolvedType = typeHandle.Resolve(); Assert.AreEqual(typeof(EnclosingType.InnerTypeUnchanged), resolvedType); }
public void Test_TypeHandle_Resolve_WorksWithRenamedTypes_WithMovedFromAttribute() { var typeStr = typeof(NewTypeName).AssemblyQualifiedName; var originalTypeStr = typeStr? .Replace("NewNamespace", "OldNamespace") .Replace("NewTypeName", "OldTypeName") .Replace("GraphTools.", "OldAssemblyName."); var typeHandle = new TypeHandle(originalTypeStr); var resolvedType = typeHandle.Resolve(); Assert.AreEqual(typeof(NewTypeName), resolvedType); }
public void Test_TypeHandle_WithNestedType_Resolve_WorksWithRenamedTypes_WithMovedFromAttribute() { var typeStr = typeof(NewNamespace.EnclosingType.InnerNew).AssemblyQualifiedName; var originalTypeStr = typeStr .Replace("NewNamespace", "OldNamespace") .Replace("InnerNew", "InnerOld") .Replace("GraphTools", "OldAssemblyName"); var typeHandle = new TypeHandle(originalTypeStr); var resolvedType = typeHandle.Resolve(m_TypeSerializer); Assert.AreEqual(typeof(NewNamespace.EnclosingType.InnerNew), resolvedType); }
public bool HasValidOperationForInput(IPortModel port, TypeHandle typeHandle) { PortName portName = ReferenceEquals(port, InputPortA) ? PortName.PortA : PortName.PortB; var otherPort = portName == PortName.PortA ? InputPortB : InputPortA; var dataType = typeHandle.Resolve(Stencil); if (otherPort.Connected) { Type otherPortType = otherPort.DataType.Resolve(Stencil); return(portName == PortName.PortB ? TypeSystem.IsBinaryOperationPossible(otherPortType, dataType, Kind) : TypeSystem.IsBinaryOperationPossible(dataType, otherPortType, Kind)); } return(TypeSystem.GetOverloadedBinaryOperators(dataType).Contains(Kind)); }
public void Test_TypeHandleDeserializationOfRenamedType_PositionTranslation() { var positionName = typeof(Translation).AssemblyQualifiedName.Replace("Translation", "Position"); Debug.Log(positionName); var typeSerializer = new CSharpTypeSerializer(new Dictionary <string, string> { { positionName, typeof(Translation).AssemblyQualifiedName } }); TypeHandle th = new TypeHandle { Identification = positionName }; Type deserializedTypeHandle = th.Resolve(typeSerializer); Assert.That(deserializedTypeHandle, Is.EqualTo(typeof(Translation))); }
/// <summary> /// Maps <see cref="TypeHandle"/> to a type of <see cref="IConstant"/>. /// </summary> public static Type GetConstantNodeType(TypeHandle typeHandle) { if (s_TypeToConstantNodeModelTypeCache == null) { s_TypeToConstantNodeModelTypeCache = new Dictionary <TypeHandle, Type> { { TypeHandle.Bool, typeof(BooleanConstant) }, { TypeHandle.Double, typeof(DoubleConstant) }, { TypeHandle.Float, typeof(FloatConstant) }, { TypeHandle.Int, typeof(IntConstant) }, { TypeHandle.Quaternion, typeof(QuaternionConstant) }, { TypeHandle.String, typeof(StringConstant) }, { TypeHandle.Vector2, typeof(Vector2Constant) }, { TypeHandle.Vector3, typeof(Vector3Constant) }, { TypeHandle.Vector4, typeof(Vector4Constant) }, { typeof(Color).GenerateTypeHandle(), typeof(ColorConstant) }, { typeof(AnimationClip).GenerateTypeHandle(), typeof(AnimationClipConstant) }, { typeof(Mesh).GenerateTypeHandle(), typeof(MeshConstant) }, { typeof(Texture2D).GenerateTypeHandle(), typeof(Texture2DConstant) }, { typeof(Texture3D).GenerateTypeHandle(), typeof(Texture3DConstant) }, }; } if (s_TypeToConstantNodeModelTypeCache.TryGetValue(typeHandle, out var result)) { return(result); } Type t = typeHandle.Resolve(); if (t.IsEnum || t == typeof(Enum)) { return(typeof(EnumConstant)); } return(null); }
public virtual bool HasValidOperationForInput(IPortModel _, TypeHandle typeHandle) { var type = typeHandle.Resolve(Stencil); return(TypeSystem.GetOverloadedUnaryOperators(type).Contains(Kind)); }
public override string GetComponentVariableName(IIteratorStackModel groupDeclaration, TypeHandle componentVariableType1) { Assert.AreEqual(groupDeclaration, IterationContext.Query); return(IterationContext.GetComponentDataName(componentVariableType1.Resolve(IterationContext.Stencil))); }
public ITypeMetadata Resolve(TypeHandle th) { if (!m_MetadataCache.TryGetValue(th, out ITypeMetadata metadata)) { metadata = m_MetadataCache.GetOrAdd(th, t => new CSharpTypeBasedMetadata(m_GraphContext, t, th.Resolve(m_GraphContext.CSharpTypeSerializer))); } return(metadata); }