private static TypeSig Resolve(TypeSig type, TypeSig typeContext)
        {
            var args = new GenericArguments();

            if (typeContext.IsGenericInstanceType)
            {
                args.PushTypeArgs(((GenericInstSig)typeContext).GenericArguments);
            }
            return(args.Resolve(type));
        }
        private static MethodSig Resolve(MethodBaseSig method, TypeSig typeContext)
        {
            var args = new GenericArguments();

            if (typeContext.IsGenericInstanceType)
            {
                args.PushTypeArgs(((GenericInstSig)typeContext).GenericArguments);
            }

            var retSig = new MethodSig(method.CallingConvention);

            retSig.RetType = args.Resolve(method.RetType);
            foreach (var param in method.Params)
            {
                retSig.Params.Add(args.Resolve(param));
            }
            return(retSig);
        }
        private static ASTType?InferVarPush(ILASTExpression expr)
        {
            var method = (IMethod)expr.Operand;

            if (method.MethodSig.RetType.ElementType == ElementType.Void)
            {
                return(null);
            }

            var genArgs = new GenericArguments();

            if (method is MethodSpec)
            {
                genArgs.PushMethodArgs(((MethodSpec)method).GenericInstMethodSig.GenericArguments);
            }
            if (method.DeclaringType.TryGetGenericInstSig() != null)
            {
                genArgs.PushTypeArgs(method.DeclaringType.TryGetGenericInstSig().GenericArguments);
            }


            return(TypeInference.ToASTType(genArgs.ResolveType(method.MethodSig.RetType)));
        }
        private static IEnumerable <TypeSig> BaseTypes(TypeSig type)
        {
            TypeDef typeDef = type.ToTypeDefOrRef().ResolveTypeDefThrow();

            if (typeDef.BaseType == null)
            {
                yield break;
            }

            TypeSig baseType = type;

            do
            {
                var args = new GenericArguments();
                if (baseType.IsGenericInstanceType)
                {
                    args.PushTypeArgs(((GenericInstSig)baseType).GenericArguments);
                }
                baseType = args.Resolve(typeDef.BaseType.ToTypeSig());
                yield return(baseType);

                typeDef = typeDef.BaseType.ResolveTypeDef();
            } while (typeDef != null && typeDef.BaseType != null);
        }
 /// <summary>
 /// Pushes the type generic arguments into resolver stack.
 /// </summary>
 /// <param name="genericArgs">The generic arguments.</param>
 public void PushTypeGenericArguments(IList <TypeSig> genericArgs)
 {
     genericArguments.PushTypeArgs(genericArgs);
 }
		void Write(CustomAttribute ca) {
			if (ca == null) {
				helper.Error("The custom attribute is null");
				return;
			}

			// Check whether it's raw first. If it is, we don't care whether the ctor is
			// invalid. Just use the raw data.
			if (ca.IsRawBlob) {
				if ((ca.ConstructorArguments != null && ca.ConstructorArguments.Count > 0) || (ca.NamedArguments != null && ca.NamedArguments.Count > 0))
					helper.Error("Raw custom attribute contains arguments and/or named arguments");
				writer.Write(ca.RawData);
				return;
			}

			if (ca.Constructor == null) {
				helper.Error("Custom attribute ctor is null");
				return;
			}

			var methodSig = GetMethodSig(ca.Constructor);
			if (methodSig == null) {
				helper.Error("Custom attribute ctor's method signature is invalid");
				return;
			}

			if (ca.ConstructorArguments.Count != methodSig.Params.Count)
				helper.Error("Custom attribute arguments count != method sig arguments count");
			if (methodSig.ParamsAfterSentinel != null && methodSig.ParamsAfterSentinel.Count > 0)
				helper.Error("Custom attribute ctor has parameters after the sentinel");
			if (ca.NamedArguments.Count > ushort.MaxValue)
				helper.Error("Custom attribute has too many named arguments");

			// A generic custom attribute isn't allowed by most .NET languages (eg. C#) but
			// the CLR probably supports it.
			var mrCtor = ca.Constructor as MemberRef;
			if (mrCtor != null) {
				var owner = mrCtor.Class as TypeSpec;
				if (owner != null) {
					var gis = owner.TypeSig as GenericInstSig;
					if (gis != null) {
						genericArguments = new GenericArguments();
						genericArguments.PushTypeArgs(gis.GenericArguments);
					}
				}
			}

			writer.Write((ushort)1);

			int numArgs = Math.Min(methodSig.Params.Count, ca.ConstructorArguments.Count);
			for (int i = 0; i < numArgs; i++)
				WriteValue(FixTypeSig(methodSig.Params[i]), ca.ConstructorArguments[i]);

			int numNamedArgs = Math.Min((int)ushort.MaxValue, ca.NamedArguments.Count);
			writer.Write((ushort)numNamedArgs);
			for (int i = 0; i < numNamedArgs; i++)
				Write(ca.NamedArguments[i]);
		}
Пример #7
0
        void Write(CustomAttribute ca)
        {
            if (ca is null)
            {
                helper.Error("The custom attribute is null");
                return;
            }

            // Check whether it's raw first. If it is, we don't care whether the ctor is
            // invalid. Just use the raw data.
            if (ca.IsRawBlob)
            {
                if ((ca.ConstructorArguments is not null && ca.ConstructorArguments.Count > 0) || (ca.NamedArguments is not null && ca.NamedArguments.Count > 0))
                {
                    helper.Error("Raw custom attribute contains arguments and/or named arguments");
                }
                writer.WriteBytes(ca.RawData);
                return;
            }

            if (ca.Constructor is null)
            {
                helper.Error("Custom attribute ctor is null");
                return;
            }

            var methodSig = GetMethodSig(ca.Constructor);

            if (methodSig is null)
            {
                helper.Error("Custom attribute ctor's method signature is invalid");
                return;
            }

            if (ca.ConstructorArguments.Count != methodSig.Params.Count)
            {
                helper.Error("Custom attribute arguments count != method sig arguments count");
            }
            if (methodSig.ParamsAfterSentinel is not null && methodSig.ParamsAfterSentinel.Count > 0)
            {
                helper.Error("Custom attribute ctor has parameters after the sentinel");
            }
            if (ca.NamedArguments.Count > ushort.MaxValue)
            {
                helper.Error("Custom attribute has too many named arguments");
            }

            if (ca.Constructor is MemberRef mrCtor && mrCtor.Class is TypeSpec owner && owner.TypeSig is GenericInstSig gis)
            {
                genericArguments = new GenericArguments();
                genericArguments.PushTypeArgs(gis.GenericArguments);
            }

            writer.WriteUInt16((ushort)1);

            int numArgs = Math.Min(methodSig.Params.Count, ca.ConstructorArguments.Count);

            for (int i = 0; i < numArgs; i++)
            {
                WriteValue(FixTypeSig(methodSig.Params[i]), ca.ConstructorArguments[i]);
            }

            int numNamedArgs = Math.Min((int)ushort.MaxValue, ca.NamedArguments.Count);

            writer.WriteUInt16((ushort)numNamedArgs);
            for (int i = 0; i < numNamedArgs; i++)
            {
                Write(ca.NamedArguments[i]);
            }
        }
        void Write(CustomAttribute ca)
        {
            if (ca == null)
            {
                helper.Error("The custom attribute is null");
                return;
            }

            // Check whether it's raw first. If it is, we don't care whether the ctor is
            // invalid. Just use the raw data.
            if (ca.IsRawBlob)
            {
                if ((ca.ConstructorArguments != null && ca.ConstructorArguments.Count > 0) || (ca.NamedArguments != null && ca.NamedArguments.Count > 0))
                {
                    helper.Error("Raw custom attribute contains arguments and/or named arguments");
                }
                writer.Write(ca.RawData);
                return;
            }

            if (ca.Constructor == null)
            {
                helper.Error("Custom attribute ctor is null");
                return;
            }

            var methodSig = GetMethodSig(ca.Constructor);

            if (methodSig == null)
            {
                helper.Error("Custom attribute ctor's method signature is invalid");
                return;
            }

            if (ca.ConstructorArguments.Count != methodSig.Params.Count)
            {
                helper.Error("Custom attribute arguments count != method sig arguments count");
            }
            if (methodSig.ParamsAfterSentinel != null && methodSig.ParamsAfterSentinel.Count > 0)
            {
                helper.Error("Custom attribute ctor has parameters after the sentinel");
            }
            if (ca.NamedArguments.Count > ushort.MaxValue)
            {
                helper.Error("Custom attribute has too many named arguments");
            }

            // A generic custom attribute isn't allowed by most .NET languages (eg. C#) but
            // the CLR probably supports it.
            var mrCtor = ca.Constructor as MemberRef;

            if (mrCtor != null)
            {
                var owner = mrCtor.Class as TypeSpec;
                if (owner != null)
                {
                    var gis = owner.TypeSig as GenericInstSig;
                    if (gis != null)
                    {
                        genericArguments = new GenericArguments();
                        genericArguments.PushTypeArgs(gis.GenericArguments);
                    }
                }
            }

            writer.Write((ushort)1);

            int numArgs = Math.Min(methodSig.Params.Count, ca.ConstructorArguments.Count);

            for (int i = 0; i < numArgs; i++)
            {
                WriteValue(FixTypeSig(methodSig.Params[i]), ca.ConstructorArguments[i]);
            }

            int numNamedArgs = Math.Min((int)ushort.MaxValue, ca.NamedArguments.Count);

            writer.Write((ushort)numNamedArgs);
            for (int i = 0; i < numNamedArgs; i++)
            {
                Write(ca.NamedArguments[i]);
            }
        }