public SemanticTypeMask_I Get(RuntimicSystemModel semanticModel, TypeReference input) { string resolutionName = Types.Naming.GetResolutionName(input); return(Get(semanticModel, resolutionName)); }
public TypeDefinition GetElementType(RuntimicSystemModel semanticModel, SemanticTypeDefinitionMask_I bound) { var genericInstanceType = (GenericInstanceType)bound.SourceTypeReference; return(GetElementType(semanticModel, genericInstanceType)); }
public StructuralModuleNode Ensure(RuntimicSystemModel runtimicSystem, StructuralAssemblyNode structuralAssemblyNode, Guid versionId) { throw new NotImplementedException(); }
public TypeReference GetTypeReference(RuntimicSystemModel model, Type input, out SemanticTypeDefinitionMask_I possibleSemanticType) { return(Infrastructure.Models.Semantic.Types.GetTypeReference(model, input, out possibleSemanticType)); }
public System.Type GetValueType(RuntimicSystemModel model) { return(GetBoundUnderlyingTypeOrThrow(model, typeof(ValueType).AssemblyQualifiedName)); }
public BoundModuleNode Get(RuntimicSystemModel model, Guid moduleMvid) { return(model.TypeSystems.Bound.Modules.ByVersionId[moduleMvid]); }
public bool Ensure(RuntimicSystemModel model, StructuralModuleNode structuralModuleNode, int typeMetadataToken, out StructuralTypeNode structuralTypeNode) { //model.TypeSystems.Structural.Types. throw new Exception(""); }
public StructuralAssemblyNode Ensure(RuntimicSystemModel semanticModel, IMetadataScope scope) { string fullName = Assemblies.Naming.GetAssemblyName(scope); return(Ensure(semanticModel, fullName)); }
public ConstructorInfo GetConstructorInfo(RuntimicSystemModel conversionModel, MemberReference memberReference) { var declaringBound = Members.GetDeclaringType(conversionModel, memberReference); return((ConstructorInfo)FindConstructorBySignature(conversionModel, declaringBound, memberReference)); }
public bool TryGet(RuntimicSystemModel model, TypeReference input, out SemanticTypeDefinitionMask_I typeEntry) { string resolutionName = Types.Naming.GetResolutionName(input); return(TryGet(model, resolutionName, out typeEntry)); }
public StructuralAssemblyNode Ensure(RuntimicSystemModel model, TypeReference typeReference) { return(Ensure(model, typeReference.Scope)); }
public bool TryGet(RuntimicSystemModel model, string resolutionName, out SemanticTypeDefinitionMask_I typeEntry) { typeEntry = Get(model, resolutionName); return(typeEntry != null); }
public SemanticTypeMask_I GetOrThrow(RuntimicSystemModel model, TypeDefinition typeDefinition) { string resolutionName = Types.Naming.GetResolutionName(typeDefinition); return(GetOrThrow(model, resolutionName)); }
public SemanticTypeDefinitionMask_I Get(RuntimicSystemModel semanticModel, string resolutionName) { throw new System.NotImplementedException(); //return Unified.Types.Get(semanticModel, resolutionName)?.SemanticType; }
public SemanticTypeInformation CreateTypeInformation(RuntimicSystemModel model, TypeReference typeReference) { //if (typeReference.FullName == // "Root.Testing.Resources.Models.E01D.Runtimic.Execution.Emitting.Conversion.Inputs.Types.GenericClassWithMethods`1" //) //{ //} string fullName = Cecil.Types.Naming.GetCliFullName(typeReference); var typeInformation = new SemanticTypeInformation { Name = typeReference.Name, FullName = fullName, TypeReference = typeReference }; if (typeReference.IsDefinition) { var typeDefinition = (TypeDefinition)typeReference; typeInformation.IsDelegate = typeDefinition.BaseType?.FullName == "System.Delegate" || typeDefinition.BaseType?.FullName == "System.MulticastDelegate"; typeInformation.IsArray = typeDefinition.IsArray; typeInformation.IsClass = typeDefinition.IsClass; typeInformation.IsInterface = typeDefinition.IsInterface; typeInformation.IsEnum = typeDefinition.IsEnum; typeInformation.IsGlobal = typeDefinition.MetadataToken.RID == 1; typeInformation.IsNested = typeDefinition.IsNested; typeInformation.IsValueType = typeDefinition.IsValueType; typeInformation.IsOpenGeneric = typeDefinition.GenericParameters.Count > 0; if (typeInformation.IsOpenGeneric) { typeInformation.GenericKind |= GenericTypeKind.Open; } if (typeDefinition.GenericParameters.Count > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters; } typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric; typeInformation.IsAnonymousType = IsAnonymousType(typeInformation.IsGeneric, typeDefinition.Name, typeDefinition.Attributes); } else if (typeReference.IsPointer) { var pointerDefinition = (PointerType)typeReference; typeInformation.IsPointer = true; typeInformation.IsDelegate = false; typeInformation.IsArray = pointerDefinition.IsArray; typeInformation.IsClass = false; typeInformation.IsInterface = false; typeInformation.IsEnum = false; typeInformation.IsGlobal = pointerDefinition.MetadataToken.RID == 1; typeInformation.IsNested = pointerDefinition.IsNested; typeInformation.IsValueType = pointerDefinition.IsValueType; typeInformation.IsOpenGeneric = pointerDefinition.GenericParameters.Count > 0; if (typeInformation.IsOpenGeneric) { typeInformation.GenericKind |= GenericTypeKind.Open; } if (pointerDefinition.GenericParameters.Count > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters; } typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric; typeInformation.IsAnonymousType = false; } else if (typeReference.IsRequiredModifier) { var requiredModifierDefinition = (RequiredModifierType)typeReference; typeInformation.IsRequiredModifier = true; typeInformation.IsDelegate = false; typeInformation.IsArray = requiredModifierDefinition.IsArray; typeInformation.IsClass = false; typeInformation.IsInterface = false; typeInformation.IsEnum = false; typeInformation.IsGlobal = requiredModifierDefinition.MetadataToken.RID == 1; typeInformation.IsNested = requiredModifierDefinition.IsNested; typeInformation.IsValueType = requiredModifierDefinition.IsValueType; typeInformation.IsOpenGeneric = requiredModifierDefinition.GenericParameters.Count > 0; if (typeInformation.IsOpenGeneric) { typeInformation.GenericKind |= GenericTypeKind.Open; } if (requiredModifierDefinition.GenericParameters.Count > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters; } typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric; typeInformation.IsAnonymousType = false; } else if (typeReference.IsArray) { typeInformation.IsDelegate = false; typeInformation.IsArray = true; typeInformation.IsClass = false; typeInformation.IsInterface = false; typeInformation.IsEnum = false; typeInformation.IsGlobal = false; typeInformation.IsNested = false; typeInformation.IsValueType = false; typeInformation.IsOpenGeneric = false; typeInformation.IsAnonymousType = false; } else if (typeReference.IsGenericInstance) { var genericInstanceType = (GenericInstanceType)typeReference; typeInformation.IsArray = genericInstanceType.IsArray; typeInformation.IsGlobal = genericInstanceType.MetadataToken.RID == 1; typeInformation.IsNested = genericInstanceType.IsNested; typeInformation.IsValueType = genericInstanceType.IsValueType; typeInformation.IsOpenGeneric = genericInstanceType.GenericParameters.Count > 0; typeInformation.IsClosedGeneric = genericInstanceType.GenericArguments.Count > 0 && !(genericInstanceType.GenericParameters.Count > 0); TypeDefinition elementTypeReference = Types.GenericInstances.GetElementType(model, genericInstanceType); typeInformation.IsDelegate = elementTypeReference.BaseType?.FullName == "System.Delegate" || elementTypeReference.BaseType?.FullName == "System.MulticastDelegate"; typeInformation.IsArray = genericInstanceType.IsArray; typeInformation.IsClass = elementTypeReference.IsClass; typeInformation.IsInterface = elementTypeReference.IsInterface; typeInformation.IsEnum = elementTypeReference.IsEnum; if (typeInformation.IsOpenGeneric) { typeInformation.GenericKind |= GenericTypeKind.Open; } if (typeInformation.IsClosedGeneric) { typeInformation.GenericKind |= GenericTypeKind.Closed; } if (genericInstanceType.GenericArguments.Count > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeArguments; } if (genericInstanceType.GenericParameters.Count > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters; } typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric; typeInformation.IsAnonymousType = IsAnonymousType(typeInformation.IsGeneric, genericInstanceType.Name, elementTypeReference.Attributes); // Add the type information before any //model.Types.TypeInformations.Add(inputType.FullName, typeInformation); if (genericInstanceType.GenericArguments.Count > 0) { var blueprint = genericInstanceType.ElementType; typeInformation.GenericTypeDefinition = blueprint; } else { throw new System.Exception("Not expected"); } } else { throw new System.Exception("Not expected"); } return(typeInformation); }
public SemanticTypeDefinitionMask_I Ensure(RuntimicSystemModel boundModel, ExecutionEnsureContext context) { GenericParameter parameter = (GenericParameter)context.TypeReference; if (parameter.DeclaringType != null) { SemanticTypeMask_I semanticDeclaringType; if (context.DeclaringType != null) { semanticDeclaringType = context.DeclaringType; } else { var resolutionName = Types.Naming.GetResolutionName(parameter.DeclaringType); semanticDeclaringType = Models.Types.GetOrThrow(boundModel, resolutionName); } if (!(semanticDeclaringType is SemanticGenericTypeDefinitionMask_I genericDeclaringType)) { throw new Exception($"Expected the resolved semantic type to be a generic type of {typeof(SemanticGenericTypeDefinitionMask_I)}."); } if (genericDeclaringType.TypeParameters.ByName.TryGetValue(parameter.Name, out SemanticGenericParameterTypeDefinitionMask_I semanticTypeParameter)) { if (!semanticTypeParameter.IsBound()) { throw new Exception("Expected the generic parameter type to be a bound type."); } return((BoundTypeDefinitionMask_I)semanticTypeParameter); } var typeParameter = CreateGenericParameter(genericDeclaringType); typeParameter.Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(parameter); typeParameter.Name = parameter.Name; typeParameter.FullName = parameter.FullName; typeParameter.Position = parameter.Position; typeParameter.TypeParameterKind = GetTypeParameterKind(parameter.Type); typeParameter.Definition = parameter; typeParameter.SourceTypeReference = parameter; //typeParameter.ResolutionName = Cecil.Types.Naming.GetResolutionName(parameter); return(typeParameter); } else { if (!(parameter.DeclaringMethod is MethodDefinition methodDefinition)) { throw new Exception("Expected a method definition"); } TypeReference declaringType; if (methodDefinition.DeclaringType != null) { declaringType = methodDefinition.DeclaringType; } else { if (context.MethodReference == null) { } declaringType = context.MethodReference.DeclaringType; } var resolutionName = Types.Naming.GetResolutionName(declaringType); var semanticType = Models.Types.GetOrThrow(boundModel, resolutionName); if (!(semanticType is BoundTypeDefinitionWithMethodsMask_I convertedTypeWithMethods)) { throw new Exception("Trying to add a method to a type that does not support methods."); } var method = Bound.Metadata.Members.Methods.Getting.FindMethodByDefinition(boundModel, convertedTypeWithMethods, methodDefinition); if (method.TypeParameters.ByName.TryGetValue(parameter.Name, out SemanticGenericParameterTypeDefinitionMask_I semanticTypeParameter)) { if (!semanticTypeParameter.IsBound()) { throw new Exception("Expected the generic parameter type to be a bound type."); } return((BoundTypeDefinitionMask_I)semanticTypeParameter); } var typeParameter = CreateGenericParameter(semanticType); typeParameter.Attributes = Cecil.Metadata.Members.GenericParameters.GetTypeParameterAttributes(parameter); typeParameter.Name = parameter.Name; typeParameter.FullName = parameter.FullName; typeParameter.Position = parameter.Position; typeParameter.TypeParameterKind = GetTypeParameterKind(parameter.Type); typeParameter.Definition = parameter; typeParameter.SourceTypeReference = parameter; typeParameter.DeclaringTypeDefinitionEntry = convertedTypeWithMethods; typeParameter.ResolutionName = Cecil.Types.Naming.GetResolutionName(parameter); //method.TypeParameters.ByName.Add(parameter.Name, typeParameter); return(typeParameter); } }
public SemanticModuleMask_I Get(RuntimicSystemModel model, System.Type type) // BELONGS HERE Because it takes in a TYPE { TypeReference typeReference = Models.Types.GetTypeReference(model, type); return(Get(model, typeReference)); }
public void Ensure(RuntimicSystemModel semanticModel, AssemblyDefinition assemblyDefinition, ModuleDefinition module, TypeDefinition typeDefinition) { Infrastructure.Models.Structural.Ensure(semanticModel, assemblyDefinition, module, typeDefinition); }
public bool ContainsGenericMethodParameters(RuntimicSystemModel boundModel, GenericInstanceType genericInstance) { throw new System.NotImplementedException(); }
public void AddAssemblyDefinition(RuntimicSystemModel semanticModel, AssemblyDefinition assemblyDefinition) { Infrastructure.Models.Structural.AddAssemblyDefinition(semanticModel, assemblyDefinition); }
public TypeReference GetTypeReference(RuntimicSystemModel model, Type input) { return(Infrastructure.Models.Semantic.Types.GetTypeReference(model, input)); }
public Type ResolveToType(RuntimicSystemModel model, SemanticTypeDefinitionMask_I semanticType) { throw new Exception("resolving a semantic type to a run time is not supported. A semantic type is designed to be used to create runtime type. Right now automatic" + "compile support is not present."); }
public TypeDefinition Resolve(RuntimicSystemModel model, Type genericTypeDefinitionType) { throw new Exception("Fix"); //return (TypeDefinition)Cecil.Types.Getting.GetStoredTypeReference(model, genericTypeDefinitionType); }
public TypeReference GetTypeReference(RuntimicSystemModel model, Type input) { return(GetTypeReference(model, input, out SemanticTypeDefinitionMask_I semanticType)); }
public System.Type GetBoundUnderlyingTypeOrThrow(RuntimicSystemModel model, string resolutionName) { var semanticType = Collection.GetOrThrow(model, resolutionName); return(GetBoundUnderlyingTypeOrThrow(semanticType)); }
public SemanticAssemblyMask_I GetAssembly(RuntimicSystemModel model, AssemblyDefinition assemblyDefinition) { return(GetAssembly(model, assemblyDefinition.FullName)); }
public void Extend(RuntimicSystemModel model, UnifiedAssemblyNode assemblyNode) { Extend(model, assemblyNode, null); }
/// <summary> /// Creates a SemanticTypeInformation instance from a System.Type. /// </summary> /// <param name="model"></param> /// <param name="inputType"></param> /// <returns></returns> public SemanticTypeInformation CreateTypeInformation(RuntimicSystemModel model, System.Type inputType) { if (inputType?.FullName == null) { return(null); } var typeInformation = new SemanticTypeInformation { Name = inputType.Name, FullName = inputType.FullName, IsDelegate = inputType.BaseType?.FullName == "System.Delegate" || inputType.BaseType?.FullName == "System.MulticastDelegate", IsArray = inputType.IsArray, IsClass = inputType.IsClass, IsInterface = inputType.IsInterface, IsEnum = inputType.IsEnum, IsOpenGeneric = inputType.ContainsGenericParameters, IsClosedGeneric = inputType.GenericTypeArguments.Length > 0 && !inputType.ContainsGenericParameters, IsGlobal = inputType.MetadataToken == 1, IsNested = inputType.IsNested, IsValueType = inputType.IsValueType, }; typeInformation.IsGeneric = typeInformation.IsOpenGeneric || typeInformation.IsClosedGeneric; typeInformation.IsAnonymousType = IsAnonymousType(inputType); if (typeInformation.IsOpenGeneric) { typeInformation.GenericKind |= GenericTypeKind.Open; } if (typeInformation.IsClosedGeneric) { typeInformation.GenericKind |= GenericTypeKind.Closed; } if (inputType.GenericTypeArguments.Length > 0) { typeInformation.GenericKind |= GenericTypeKind.HasTypeArguments; } if (inputType.ContainsGenericParameters) { typeInformation.GenericKind |= GenericTypeKind.HasTypeParameters; } // Add the type information before any //model.Types.TypeInformations.Add(inputType.FullName, typeInformation); if (inputType.GenericTypeArguments.Length > 0) { var blueprint = inputType.GetGenericTypeDefinition(); typeInformation.GenericTypeDefinition = Cecil.Types.Getting.GetStoredTypeReference(model, blueprint); } else { typeInformation.TypeReference = Cecil.Types.Getting.GetStoredTypeReference(model, inputType); } //// The issue is that type arguments can be generics themselves. //// The issue also is that arguments could have already been created. //typeInformation.TypeArguments = GetTypeParameters(model, inputType); //typeInformation.Interfaces = GetInterfaces(model, inputType); return(typeInformation); }
/// <summary> /// Resolves a type parameter for when a generic instance method is being created. /// This should not be used for resolving generic instance methods that are instructions as /// generic instance method arguments are not resolved. /// </summary> /// <param name="model"></param> /// <param name="genericInstanceTypeArguments"></param> /// <param name="typeToResolve"></param> /// <returns></returns> public TypeReference ResolveTypeParameterIfPresent(RuntimicSystemModel model, TypeReference[] genericInstanceTypeArguments, TypeReference typeToResolve) { if (typeToResolve.IsByReference) { var inputByReferenceType = (ByReferenceType)typeToResolve; var inputByReferenceTypeElement = inputByReferenceType.ElementType; var result = ResolveTypeParameterIfPresent(model, genericInstanceTypeArguments, inputByReferenceTypeElement); return(new ByReferenceType(result)); } if (typeToResolve.IsArray) { var arrayType = (ArrayType)typeToResolve; var rank = arrayType.Rank; var arrayElementType = arrayType.ElementType; var arrayElementReferenceType = ResolveTypeParameterIfPresent(model, genericInstanceTypeArguments, arrayElementType); if (rank == 1) { return(new ArrayType(arrayElementReferenceType)); } else { return(new ArrayType(arrayElementReferenceType, rank)); } } if (typeToResolve.IsGenericInstance) { GenericInstanceType genericInstanceType = (GenericInstanceType)typeToResolve; var genericInstanceTypeDef = ResolveTypeParameterIfPresent(model, genericInstanceTypeArguments, genericInstanceType.ElementType); TypeReference[] arguments = new TypeReference[genericInstanceType.GenericArguments.Count]; for (int i = 0; i < genericInstanceType.GenericArguments.Count; i++) { arguments[i] = ResolveTypeParameterIfPresent(model, genericInstanceTypeArguments, genericInstanceType.GenericArguments[i]); } return(genericInstanceTypeDef.MakeGenericInstanceType(arguments)); } if (!typeToResolve.IsGenericParameter) { return(Infrastructure.Structural.Types.Ensure(model, typeToResolve).CecilTypeReference); } var genericParameter = (GenericParameter)typeToResolve; if (genericParameter.Type == GenericParameterType.Type) { // Becauase there is different generic instance type is created for each set of type arguments, generic parameters that are // type arguments can be replaced. return(genericInstanceTypeArguments[genericParameter.Position]); } else { // This method is called when creating method references for all instructions that might encounter this method reference. // When this method is built, there is no way to know ahead of time what instructions might be calling it. Thus, this needs to // return just the method type parameter. return(typeToResolve); } }
public System.Type EnsureToType(RuntimicSystemModel model, TypeReference typeReference, out BoundTypeDefinitionMask_I boundType) { return(EnsureToType(model, typeReference, null, out boundType)); }