static string GetSignatureForDoc(Type type) { #if GMCS_SOURCE if (TypeManager.IsGenericParameter(type)) { return((type.DeclaringMethod != null ? "``" : "`") + TypeManager.GenericParameterPosition(type)); } if (TypeManager.IsGenericType(type)) { string g = type.Namespace; if (g != null && g.Length > 0) { g += '.'; } int idx = type.Name.LastIndexOf('`'); g += (idx < 0 ? type.Name : type.Name.Substring(0, idx)) + '{'; int argpos = 0; foreach (Type t in type.GetGenericArguments()) { g += (argpos++ > 0 ? "," : String.Empty) + GetSignatureForDoc(t); } g += '}'; return(g); } #endif string name = type.FullName != null ? type.FullName : type.Name; return(name.Replace("+", ".").Replace('&', '@')); }
static string GetSignatureForDoc(TypeSpec type) { var tp = type as TypeParameterSpec; if (tp != null) { int c = 0; type = type.DeclaringType; while (type != null && type.DeclaringType != null) { type = type.DeclaringType; c += type.MemberDefinition.TypeParametersCount; } var prefix = tp.IsMethodOwned ? "``" : "`"; return(prefix + (c + tp.DeclaredPosition)); } var pp = type as PointerContainer; if (pp != null) { return(GetSignatureForDoc(pp.Element) + "*"); } ArrayContainer ap = type as ArrayContainer; if (ap != null) { return(GetSignatureForDoc(ap.Element) + ArrayContainer.GetPostfixSignature(ap.Rank)); } if (TypeManager.IsGenericType(type)) { string g = type.MemberDefinition.Namespace; if (g != null && g.Length > 0) { g += '.'; } int idx = type.Name.LastIndexOf('`'); g += (idx < 0 ? type.Name : type.Name.Substring(0, idx)) + '{'; int argpos = 0; foreach (TypeSpec t in TypeManager.GetTypeArguments(type)) { g += (argpos++ > 0 ? "," : String.Empty) + GetSignatureForDoc(t); } g += '}'; return(g); } string name = type.GetMetaInfo().FullName != null?type.GetMetaInfo().FullName : type.Name; return(name.Replace("+", ".").Replace('&', '@')); }
// // Returns the MethodBase for "Invoke" from a delegate type, this is used // to extract the signature of a delegate. // public static MethodInfo GetInvokeMethod(CompilerContext ctx, Type container_type, Type delegate_type) { Type dt = delegate_type; Type[] g_args = null; if (TypeManager.IsGenericType(delegate_type)) { g_args = TypeManager.GetTypeArguments(delegate_type); delegate_type = TypeManager.DropGenericTypeArguments(delegate_type); } Delegate d = TypeManager.LookupDelegate(delegate_type); MethodInfo invoke; if (d != null) { #if GMCS_SOURCE if (g_args != null) { invoke = TypeBuilder.GetMethod(dt, d.InvokeBuilder); #if MS_COMPATIBLE ParametersCompiled p = (ParametersCompiled)d.Parameters.InflateTypes(g_args, g_args); TypeManager.RegisterMethod(invoke, p); #endif return(invoke); } #endif return(d.InvokeBuilder); } Expression ml = Expression.MemberLookup(ctx, container_type, null, dt, "Invoke", Location.Null); MethodGroupExpr mg = ml as MethodGroupExpr; if (mg == null) { ctx.Report.Error(-100, Location.Null, "Internal error: could not find Invoke method!"); // FIXME: null will cause a crash later return(null); } invoke = (MethodInfo)mg.Methods[0]; #if MS_COMPATIBLE if (g_args != null) { AParametersCollection p = TypeManager.GetParameterData(invoke); p = p.InflateTypes(g_args, g_args); TypeManager.RegisterMethod(invoke, p); return(invoke); } #endif return(invoke); }
static bool CheckType(Type ret, out Type original_iterator_type, out bool is_enumerable) { original_iterator_type = null; is_enumerable = false; if (ret == TypeManager.ienumerable_type) { original_iterator_type = TypeManager.object_type; is_enumerable = true; return(true); } if (ret == TypeManager.ienumerator_type) { original_iterator_type = TypeManager.object_type; is_enumerable = false; return(true); } if (!TypeManager.IsGenericType(ret)) { return(false); } Type[] args = TypeManager.GetTypeArguments(ret); if (args.Length != 1) { return(false); } Type gt = TypeManager.DropGenericTypeArguments(ret); if (gt == TypeManager.generic_ienumerable_type) { original_iterator_type = args [0]; is_enumerable = true; return(true); } if (gt == TypeManager.generic_ienumerator_type) { original_iterator_type = args [0]; is_enumerable = false; return(true); } return(false); }
public static ConstructorInfo GetConstructor(CompilerContext ctx, Type container_type, Type delegate_type) { Type dt = delegate_type; Type[] g_args = null; if (TypeManager.IsGenericType(delegate_type)) { g_args = TypeManager.GetTypeArguments(delegate_type); delegate_type = TypeManager.DropGenericTypeArguments(delegate_type); } Delegate d = TypeManager.LookupDelegate(delegate_type); if (d != null) { #if GMCS_SOURCE if (g_args != null) { return(TypeBuilder.GetConstructor(dt, d.ConstructorBuilder)); } #endif return(d.ConstructorBuilder); } Expression ml = Expression.MemberLookup(ctx, container_type, null, dt, ConstructorInfo.ConstructorName, MemberTypes.Constructor, BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly, Location.Null); MethodGroupExpr mg = ml as MethodGroupExpr; if (mg == null) { ctx.Report.Error(-100, Location.Null, "Internal error: could not find delegate constructor!"); // FIXME: null will cause a crash later return(null); } return((ConstructorInfo)mg.Methods[0]); }
/// <summary> /// Check whether `a' and `b' may become equal generic types. /// The algorithm to do that is a little bit complicated. /// </summary> static bool MayBecomeEqualGenericTypes(TypeSpec a, TypeSpec b) { if (a.IsGenericParameter) { // // If a is an array of a's type, they may never // become equal. // if (b.IsArray) { return(false); } // // If b is a generic parameter or an actual type, // they may become equal: // // class X<T,U> : I<T>, I<U> // class X<T> : I<T>, I<float> // if (b.IsGenericParameter) { return(a.DeclaringType == b.DeclaringType); } // // We're now comparing a type parameter with a // generic instance. They may become equal unless // the type parameter appears anywhere in the // generic instance: // // class X<T,U> : I<T>, I<X<U>> // -> error because you could instanciate it as // X<X<int>,int> // // class X<T> : I<T>, I<X<T>> -> ok // return(!ContainsTypeParameter(a, b)); } if (b.IsGenericParameter) { return(MayBecomeEqualGenericTypes(b, a)); } // // At this point, neither a nor b are a type parameter. // // If one of them is a generic instance, compare them (if the // other one is not a generic instance, they can never // become equal). // if (TypeManager.IsGenericType(a) || TypeManager.IsGenericType(b)) { return(IsEqual(a, b)); } // // If both of them are arrays. // var a_ac = a as ArrayContainer; if (a_ac != null) { var b_ac = b as ArrayContainer; if (b_ac == null || a_ac.Rank != b_ac.Rank) { return(false); } return(MayBecomeEqualGenericTypes(a_ac.Element, b_ac.Element)); } // // Ok, two ordinary types. // return(false); }