/// <summary> /// Resolves a property reference. /// </summary> /// <param name="propertyRef">The property reference to resolve.</param> /// <param name="assembly">The assembly that declares the reference.</param> /// <returns>The property referred to by the reference.</returns> internal IProperty Resolve( PropertyReference propertyRef, ClrAssembly assembly) { var declaringType = Resolve(propertyRef.DeclaringType, assembly); var standinReplacer = CreateStandinReplacingVisitor(declaringType); var propertyType = TypeHelpers.BoxIfReferenceType( standinReplacer.Visit(Resolve(propertyRef.PropertyType, assembly, declaringType, true))); var parameterTypes = propertyRef.Parameters .Select(param => TypeHelpers.BoxIfReferenceType( standinReplacer.Visit( Resolve(param.ParameterType, assembly, declaringType, true)))) .ToImmutableArray(); return(PickSingleResolvedMember( propertyRef, propertyIndex.GetAll( declaringType, ClrPropertySignature.Create( propertyRef.Name, propertyType, parameterTypes)))); }
private void AnalyzeContents() { fieldTypeValue = TypeHelpers.BoxIfReferenceType( ParentType.Assembly.Resolve(Definition.FieldType)); var attrBuilder = new AttributeMapBuilder(); // TODO: analyze attributes. attributeMap = new AttributeMap(attrBuilder); }
private IType BoxTypeArgumentIfNecessary(IType typeArgument, IGenericParameter parameter) { if (parameter.IsReferenceType()) { // Already pre-boxed. return(typeArgument); } else { return(TypeHelpers.BoxIfReferenceType(typeArgument)); } }
private void AnalyzeContents() { fieldTypeValue = TypeHelpers.BoxIfReferenceType( ParentType.Assembly.Resolve(Definition.FieldType)); var attrBuilder = new AttributeMapBuilder(); // Analyze access modifier. attrBuilder.Add(AccessModifierAttribute.Create(AnalyzeAccessModifier())); // TODO: analyze other attributes. attributeMap = new AttributeMap(attrBuilder); }
/// <summary> /// Resolves a method reference. /// </summary> /// <param name="methodRef">The method reference to resolve.</param> /// <param name="assembly">The assembly that declares the reference.</param> /// <returns>The method referred to by the reference.</returns> internal IMethod Resolve(MethodReference methodRef, ClrAssembly assembly) { if (methodRef is MethodSpecification) { if (methodRef is GenericInstanceMethod) { var genInstMethod = (GenericInstanceMethod)methodRef; var elemMethod = Resolve(genInstMethod.ElementMethod, assembly); return(elemMethod.MakeGenericMethod( genInstMethod.GenericArguments .Select(arg => Resolve(arg, assembly)) .Zip(elemMethod.GenericParameters, BoxTypeArgumentIfNecessary) .ToArray())); } else { throw new NotSupportedException( "Cannot resolve unsupported method specification type " + $"'{methodRef.GetType()}' for method reference '{methodRef}'."); } } var declaringType = Resolve(methodRef.DeclaringType, assembly); var name = NameConversion.ParseSimpleName(methodRef.Name); var standinReplacer = CreateStandinReplacingVisitor(declaringType); var standinRetType = Resolve(methodRef.ReturnType, assembly, declaringType, true); var returnType = TypeHelpers.BoxIfReferenceType( standinReplacer.Visit(standinRetType)); var parameterTypes = methodRef.Parameters .Select(param => TypeHelpers.BoxIfReferenceType( standinReplacer.Visit( Resolve(param.ParameterType, assembly, declaringType, true)))) .ToArray(); return(PickSingleResolvedMember( methodRef, methodIndex.GetAll( declaringType, ClrMethodSignature.Create( name, methodRef.GenericParameters.Count, returnType, parameterTypes)))); }
internal static Parameter WrapReturnParameter( MethodReturnType returnParameter, ClrAssembly assembly, IGenericMember enclosingMember) { var attrBuilder = new AttributeMapBuilder(); // TODO: actually analyze the parameter's attributes. return(new Parameter( TypeHelpers.BoxIfReferenceType( assembly.Resolve( returnParameter.ReturnType, enclosingMember)), returnParameter.Name, new AttributeMap(attrBuilder))); }
/// <summary> /// Resolves a field reference. /// </summary> /// <param name="fieldRef">The field reference to resolve.</param> /// <param name="assembly">The assembly that declares the reference.</param> /// <returns>The field referred to by the reference.</returns> internal IField Resolve(FieldReference fieldRef, ClrAssembly assembly) { var declaringType = Resolve(fieldRef.DeclaringType, assembly); var standinReplacer = CreateStandinReplacingVisitor(declaringType); var fieldType = TypeHelpers.BoxIfReferenceType( standinReplacer.Visit( Resolve(fieldRef.FieldType, assembly, declaringType, true))); return(PickSingleResolvedMember( fieldRef, fieldIndex.GetAll( declaringType, new KeyValuePair <string, IType>( fieldRef.Name, fieldType)))); }
private void AnalyzeContents() { var assembly = ParentType.Assembly; propertyTypeValue = TypeHelpers.BoxIfReferenceType( assembly.Resolve(Definition.PropertyType, ParentType)); // Analyze the parameter list. indexerParams = Definition.Parameters .Select(param => ClrMethodDefinition.WrapParameter( param, assembly, ParentType)) .ToArray(); var attrBuilder = new AttributeMapBuilder(); // TODO: analyze attributes. attributeMap = new AttributeMap(attrBuilder); }
/// <summary> /// Resolves a type reference. /// </summary> /// <param name="typeRef">The type reference to resolve.</param> /// <param name="assembly">The assembly in which the reference occurs.</param> /// <param name="enclosingMember"> /// The generic member that references a particular type. If non-null, type /// parameters are resolved from this member. /// </param> /// <param name="useStandins"> /// A Boolean that specifies if stand-ins should be used for generic parameters. /// </param> /// <returns>The type referred to by the reference.</returns> private IType Resolve( TypeReference typeRef, ClrAssembly assembly, IGenericMember enclosingMember, bool useStandins) { if (typeRef is TypeSpecification) { var typeSpec = (TypeSpecification)typeRef; var elemType = Resolve(typeSpec.ElementType, assembly, enclosingMember, useStandins); if (typeSpec is GenericInstanceType) { var genInstType = (GenericInstanceType)typeSpec; return(elemType.MakeRecursiveGenericType( genInstType.GenericArguments .Select(arg => Resolve(arg, assembly, enclosingMember, useStandins)) .Zip(elemType.GetRecursiveGenericParameters(), BoxTypeArgumentIfNecessary) .ToArray())); } else if (typeSpec is Mono.Cecil.PointerType) { return(TypeHelpers.BoxIfReferenceType(elemType) .MakePointerType(PointerKind.Transient)); } else if (typeSpec is ByReferenceType) { return(TypeHelpers.BoxIfReferenceType(elemType) .MakePointerType(PointerKind.Reference)); } else if (typeSpec is Mono.Cecil.ArrayType) { var arraySpec = (Mono.Cecil.ArrayType)typeSpec; var boxedElem = TypeHelpers.BoxIfReferenceType(elemType); IType arrayType; if (TypeEnvironment.TryMakeArrayType( boxedElem, arraySpec.Rank, out arrayType)) { return(arrayType); } else { throw new NotSupportedException( "Cannot resolve array specification '" + typeSpec.ToString() + "' because the type environment " + "does not support arrays with that element type and rank."); } } else if (typeSpec is Mono.Cecil.IModifierType) { var modType = Resolve( ((Mono.Cecil.IModifierType)typeSpec).ModifierType, assembly, enclosingMember, useStandins); return(ClrModifierType.Create(elemType, modType, typeSpec.IsRequiredModifier)); } else { throw new NotSupportedException( "Unsupported kind of type specification '" + typeSpec.ToString() + "'."); } } else if (typeRef is GenericParameter) { var genericParam = (GenericParameter)typeRef; if (useStandins) { return(ClrGenericParameterStandin.Create( genericParam.Type, genericParam.Position)); } else if (genericParam.DeclaringMethod == null) { var declType = enclosingMember is IType ? (IType)enclosingMember : enclosingMember is IMethod ? ((IMethod)enclosingMember).ParentType : Resolve( genericParam.DeclaringType, assembly, enclosingMember, useStandins); return(declType.GetRecursiveGenericParameters()[genericParam.Position]); } else { var declMethod = enclosingMember is IMethod ? (IMethod)enclosingMember : Resolve(genericParam.DeclaringMethod, assembly); return(declMethod.GenericParameters[genericParam.Position]); } } else { if (typeRef.DeclaringType != null) { var declType = Resolve( typeRef.DeclaringType, assembly, enclosingMember, useStandins); var nestedTypes = GetTypeResolver(assembly).ResolveNestedTypes( declType, NameConversion.ParseSimpleName(typeRef.Name)); return(PickSingleResolvedType(typeRef, nestedTypes)); } var scope = typeRef.Scope; if (scope == null) { throw new ResolutionException(typeRef); } switch (scope.MetadataScopeType) { case MetadataScopeType.AssemblyNameReference: return(FindInAssembly(typeRef, Resolve((AssemblyNameReference)scope))); case MetadataScopeType.ModuleDefinition: case MetadataScopeType.ModuleReference: default: return(FindInAssembly(typeRef, assembly)); } } }