private static IEnumerable <XObject> GenerateAttributeArgument(IProcessingContext context, CustomAttributeTypedArgument cata) { // TODO this needs to be cleaned up, and fixed context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType)); yield return(new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType))); if (cata.ArgumentType.IsEnum) { if ( cata.ArgumentType.GetCustomAttributesData().Any( ca => ca.Constructor.DeclaringType == typeof(FlagsAttribute))) { string flags = Enum.ToObject(cata.ArgumentType, cata.Value).ToString(); string[] parts = flags.Split(','); yield return (new XElement("literal", new XAttribute("value", cata.Value), Array.ConvertAll(parts, s => new XElement("flag", new XAttribute("value", s.Trim()))))); } else { string value = Enum.GetName(cata.ArgumentType, cata.Value); if (value != null) { yield return(new XElement("literal", new XAttribute("value", value))); } yield return(new XElement("literal", new XAttribute("value", cata.Value))); } } else if (cata.ArgumentType == typeof(Type)) { XElement tmp = new XElement("tmp"); DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value"); yield return(tmp.Attribute("value")); foreach (XElement xElement in tmp.Elements()) { yield return(xElement); } } else // TODO fix how this encodes unprintable characters { yield return(new XAttribute("value", cata.Value.ToString().Replace("\0", "\\0"))); } }
private void GenerateImplementsElement(IProcessingContext context, MemberInfo mInfo) { Type declaringType = mInfo.DeclaringType; if (declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition) declaringType = declaringType.GetGenericTypeDefinition(); if (!declaringType.IsInterface) { Type[] interfaces = declaringType.GetInterfaces(); foreach (Type ifType in interfaces) { if (context.IsFiltered(AssetIdentifier.FromMemberInfo(ifType))) continue; InterfaceMapping ifMap = declaringType.GetInterfaceMap(ifType); if (ifMap.TargetType != declaringType) continue; var targetMethod = ifMap.TargetMethods.SingleOrDefault(mi => mi.MetadataToken == mInfo.MetadataToken && mi.Module == mInfo.Module); if (targetMethod != null) { int mIx = Array.IndexOf(ifMap.TargetMethods, targetMethod); AssetIdentifier miAid; if (ifMap.InterfaceMethods[mIx].DeclaringType.IsGenericType) { Type declType = ifMap.InterfaceMethods[mIx].DeclaringType.GetGenericTypeDefinition(); MethodInfo[] allMethods = declType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); miAid = AssetIdentifier.FromMemberInfo(allMethods.Single(mi => mi.MetadataToken == ifMap.InterfaceMethods[mIx].MetadataToken && mi.Module == ifMap.InterfaceMethods[mIx].Module)); } else { miAid = AssetIdentifier.FromMemberInfo(ifMap.InterfaceMethods[mIx]); } context.Element.Add(new XElement("implements", new XAttribute("member", miAid))); context.AddReference(miAid); } } } }
private XElement GenerateMethodElement(IProcessingContext context, AssetIdentifier assetId) { // Debug.Assert(context.Element.Name.LocalName != "type", "Cannot put Method into closed generic type"); MethodBase mBase = (MethodBase)context.AssetResolver.Resolve(assetId); if (mBase is ConstructorInfo) return this.GenerateConstructorElement(context, assetId); MethodInfo mInfo = (MethodInfo)mBase; string elemName; if (this.IsOperator(mInfo)) elemName = "operator"; else elemName = "method"; XElement ret = new XElement(elemName, new XAttribute("name", mInfo.Name), new XAttribute("assetId", assetId), new XAttribute("phase", context.Phase)); context.Element.Add(ret); Type declaringType = mInfo.DeclaringType; if (declaringType.IsGenericType && !declaringType.IsGenericTypeDefinition) declaringType = declaringType.GetGenericTypeDefinition(); MethodInfo realMethodInfo = declaringType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static).Single( mi => mi.MetadataToken == mInfo.MetadataToken && mi.Module == mInfo.Module); AssetIdentifier declaredAs = AssetIdentifier.FromMemberInfo(realMethodInfo); if (declaringType != mInfo.ReflectedType) { ret.Add(new XAttribute("declaredAs", declaredAs)); context.AddReference(declaredAs); } else if (realMethodInfo.GetBaseDefinition() != realMethodInfo) { MethodInfo baseMethod = realMethodInfo.GetBaseDefinition(); if (baseMethod.ReflectedType.IsGenericType) { Type realTypeBase = baseMethod.ReflectedType.GetGenericTypeDefinition(); MethodInfo[] allMethods = realTypeBase.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static); baseMethod = allMethods.Single( m => m.Module == baseMethod.Module && m.MetadataToken == baseMethod.MetadataToken); } declaredAs = AssetIdentifier.FromMemberInfo(baseMethod); ret.Add(new XAttribute("overrides", declaredAs)); context.AddReference(declaredAs); } this.GenerateImplementsElement(context.Clone(ret), mInfo); this.GenerateAccessModifiers(ret, mInfo); if (mInfo.ContainsGenericParameters) { Type[] typeParams = mInfo.GetGenericArguments(); foreach (Type tp in typeParams) this.GenerateTypeParamElement(context.Clone(ret), mInfo, tp); } foreach (IEnricher item in this.Enrichers) item.EnrichMethod(context.Clone(ret), mInfo); ParameterInfo[] methodParams = mInfo.GetParameters(); this.GenerateParameterElements(context.Clone(ret), methodParams); if (mInfo.ReturnType != typeof(void)) { XElement retElem = new XElement("returns"); GenerateTypeRef(context.Clone(retElem), mInfo.ReturnType); foreach (IEnricher item in this.Enrichers) item.EnrichReturnValue(context.Clone(retElem), mInfo); ret.Add(retElem); } return ret; }
private XElement GenerateTypeElement(IProcessingContext context, AssetIdentifier assetId) { XElement ret; Type type = (Type)context.AssetResolver.Resolve(assetId); string elemName; if (type.IsClass) elemName = "class"; else if (type.IsEnum) elemName = "enum"; else if (type.IsValueType) elemName = "struct"; else if (type.IsInterface) elemName = "interface"; else throw new ArgumentException("Unknown asset type: " + assetId.Type.ToString(), "assetId"); ret = new XElement(elemName, new XAttribute("name", type.Name), new XAttribute("assetId", assetId), new XAttribute("phase", context.Phase)); if (type.IsEnum) { AssetIdentifier aid = AssetIdentifier.FromType(type.GetEnumUnderlyingType()); ret.Add(new XAttribute("underlyingType", aid)); context.AddReference(aid); } if (!type.IsInterface && type.IsAbstract) ret.Add(new XAttribute("isAbstract", XmlConvert.ToString(type.IsAbstract))); if (!type.IsVisible || type.IsNested && type.IsNestedAssembly) ret.Add(new XAttribute("isInternal", XmlConvert.ToString(true))); if (type.IsPublic || type.IsNested && type.IsNestedPublic) ret.Add(new XAttribute("isPublic", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedPrivate) ret.Add(new XAttribute("isPrivate", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamily) ret.Add(new XAttribute("isProtected", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamANDAssem) ret.Add(new XAttribute("isProtectedAndInternal", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamORAssem) ret.Add(new XAttribute("isProtectedOrInternal", XmlConvert.ToString(true))); if (type.IsClass && type.IsSealed) ret.Add(new XAttribute("isSealed", XmlConvert.ToString(true))); if (type.BaseType != null) { AssetIdentifier baseAid = AssetIdentifier.FromType(type.BaseType); if (!context.IsFiltered(baseAid)) { var inheritsElem = new XElement("inherits"); ret.Add(inheritsElem); GenerateTypeRef(context.Clone(inheritsElem), type.BaseType); } } if (type.ContainsGenericParameters) { Type[] typeParams = type.GetGenericArguments(); foreach (Type tp in typeParams) { this.GenerateTypeParamElement(context.Clone(ret), type, tp); } } if (type.IsClass) { foreach (Type interfaceType in type.GetInterfaces()) { InterfaceMapping mapping = type.GetInterfaceMap(interfaceType); if (mapping.TargetType == type) { AssetIdentifier interfaceAssetId = AssetIdentifier.FromType(interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : interfaceType); if (!context.IsFiltered(interfaceAssetId)) { var implElement = new XElement("implements"); ret.Add(implElement); GenerateTypeRef(context.Clone(implElement), interfaceType, "interface"); } } } } foreach (IEnricher enricher in this._enrichers) enricher.EnrichType(context.Clone(ret), type); context.Element.Add(ret); return ret; }
public static void GenerateTypeRef(IProcessingContext context, Type pType, string attrName = null) { if (pType.IsArray) { var arrayElem = new XElement("arrayOf", new XAttribute("rank", pType.GetArrayRank())); context.Element.Add(arrayElem); GenerateTypeRef(context.Clone(arrayElem), pType.GetElementType()); } else { if (pType.IsGenericParameter) context.Element.Add(new XAttribute("param", pType.Name)); else if (pType.IsGenericType) { AssetIdentifier aid = AssetIdentifier.FromType(pType.GetGenericTypeDefinition()); context.AddReference(aid); context.Element.Add(new XAttribute(attrName ?? "type", aid)); foreach (Type genArg in pType.GetGenericArguments()) { XElement argElem = new XElement("with"); GenerateTypeRef(context.Clone(argElem), genArg); context.Element.Add(argElem); } } else { AssetIdentifier aid = AssetIdentifier.FromMemberInfo(pType); context.AddReference(aid); context.Element.Add(new XAttribute(attrName ?? "type", aid)); } } }
private static void GenerateAttributeElements(IProcessingContext context, IEnumerable<CustomAttributeData> attrData) { foreach (CustomAttributeData custAttr in attrData) { context.AddReference(AssetIdentifier.FromMemberInfo(custAttr.Constructor)); var attrElem = new XElement("attribute", new XAttribute("type", AssetIdentifier.FromMemberInfo( custAttr.Constructor. ReflectedType ?? custAttr.Constructor. DeclaringType)), new XAttribute("constructor", AssetIdentifier.FromMemberInfo(custAttr.Constructor))); foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments) { if (cta.Value is ReadOnlyCollection<CustomAttributeTypedArgument>) { AssetIdentifier elementAssetId = AssetIdentifier.FromMemberInfo(cta.ArgumentType.GetElementType()); context.AddReference(elementAssetId); attrElem.Add(new XElement("argument", new XElement("array", new XAttribute("type", elementAssetId), ((IEnumerable<CustomAttributeTypedArgument>)cta.Value). Select( ata => new XElement("element", GenerateAttributeArgument( context, ata)))))); } else { attrElem.Add(new XElement("argument", GenerateAttributeArgument(context, cta))); } } foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments) { AssetIdentifier namedMember = AssetIdentifier.FromMemberInfo(cta.MemberInfo); context.AddReference(namedMember); if (cta.TypedValue.Value is ReadOnlyCollection<CustomAttributeTypedArgument>) { context.AddReference(namedMember); AssetIdentifier elementAssetId = AssetIdentifier.FromMemberInfo(cta.TypedValue.ArgumentType.GetElementType()); context.AddReference(elementAssetId); attrElem.Add(new XElement("argument", new XAttribute("member", namedMember), new XElement("array", new XAttribute("type", elementAssetId), ((IEnumerable<CustomAttributeTypedArgument>) cta.TypedValue.Value).Select( ata => new XElement("element", GenerateAttributeArgument (context, ata)))))); } else { attrElem.Add(new XElement("argument", new XAttribute("member", namedMember), GenerateAttributeArgument(context, cta.TypedValue))); } } context.Element.Add(attrElem); } }
private static IEnumerable<XObject> GenerateAttributeArgument(IProcessingContext context, CustomAttributeTypedArgument cata) { context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType)); yield return new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType)); if (cata.ArgumentType.IsEnum) { if ( cata.ArgumentType.GetCustomAttributesData().Any( ca => ca.Constructor.DeclaringType == typeof(FlagsAttribute))) { var parts = GetEnumFlags(cata.ArgumentType, cata.Value).ToArray(); yield return new XElement("enum", Array.ConvertAll(parts, s => new XElement("flag", new XAttribute("value", s.Trim())))); } else { var val = Enum.GetName(cata.ArgumentType, cata.Value) ?? ""; yield return new XElement("enum", new XAttribute("value", val)); } } else if (cata.ArgumentType == typeof(Type)) { XElement tmp = new XElement("tmp"); DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value"); yield return tmp.Attribute("value"); foreach (XElement xElement in tmp.Elements()) yield return xElement; // yield return new XAttribute("value", AssetIdentifier.FromMemberInfo((Type)cata.Value)); } else yield return new XAttribute("value", cata.Value.ToString()); }
private XElement GenerateTypeElement(IProcessingContext context, Asset asset) { XElement ret; Type type = (Type)asset.Target; string elemName; if (type.IsClass) elemName = "class"; else if (type.IsEnum) elemName = "enum"; else if (type.IsValueType) elemName = "struct"; else if (type.IsInterface) elemName = "interface"; else throw new ArgumentException("Unknown asset type: " + asset.Type.ToString(), "asset"); //XTypeBuilder typeBuilder = new XTypeBuilder(type.Name, asset.Id, context.Phase); //typeBuilder.A //ret = typeBuilder.ToElement(); ret = new XElement(elemName, new XAttribute("name", type.Name), new XAttribute("assetId", asset.Id), new XAttribute("phase", context.Phase)); if (type.IsEnum) { Type underlyingType = type.GetEnumUnderlyingType(); AssetIdentifier aid = AssetIdentifier.FromType(underlyingType); ret.Add(new XAttribute("underlyingType", aid)); context.AddReference(new Asset(aid, underlyingType)); } if (!type.IsInterface && type.IsAbstract) ret.Add(new XAttribute("isAbstract", XmlConvert.ToString(type.IsAbstract))); if (!type.IsVisible || type.IsNested && type.IsNestedAssembly) ret.Add(new XAttribute("isInternal", XmlConvert.ToString(true))); if (type.IsPublic || type.IsNested && type.IsNestedPublic) ret.Add(new XAttribute("isPublic", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedPrivate) ret.Add(new XAttribute("isPrivate", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamily) ret.Add(new XAttribute("isProtected", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamANDAssem) ret.Add(new XAttribute("isProtectedAndInternal", XmlConvert.ToString(true))); if (type.IsNested && type.IsNestedFamORAssem) ret.Add(new XAttribute("isProtectedOrInternal", XmlConvert.ToString(true))); if (type.IsClass && type.IsSealed) ret.Add(new XAttribute("isSealed", XmlConvert.ToString(true))); if (type.BaseType != null) { AssetIdentifier baseAid = AssetIdentifier.FromType(type.BaseType); Asset baseAsset = new Asset(baseAid, type.BaseType); if (!context.IsFiltered(baseAsset)) { var inheritsElem = new XElement("inherits"); ret.Add(inheritsElem); GenerateTypeRef(context.Clone(inheritsElem), type.BaseType); } } if (type.ContainsGenericParameters) { Type[] typeParams = type.GetGenericArguments(); if (type.IsNested && type.DeclaringType.ContainsGenericParameters) { Type[] inheritedTypeParams = type.DeclaringType.GetGenericArguments(); Debug.Assert(typeParams.Length >= inheritedTypeParams.Length); for (int paramPos = 0; paramPos < inheritedTypeParams.Length; paramPos++) { Debug.Assert(typeParams[paramPos].Name == inheritedTypeParams[paramPos].Name); Debug.Assert(typeParams[paramPos].GenericParameterAttributes == inheritedTypeParams[paramPos].GenericParameterAttributes); } Type[] declaredTypeParams = new Type[typeParams.Length - inheritedTypeParams.Length]; for (int paramPos = inheritedTypeParams.Length; paramPos < typeParams.Length; paramPos++) { declaredTypeParams[paramPos - inheritedTypeParams.Length] = typeParams[paramPos]; } typeParams = declaredTypeParams; } foreach (Type tp in typeParams) { this.GenerateTypeParamElement(context.Clone(ret), type, tp); } } if (type.IsClass) { foreach (Type interfaceType in type.GetInterfaces()) { InterfaceMapping mapping = type.GetInterfaceMap(interfaceType); if (mapping.TargetMethods.Any(mi => mi.DeclaringType == type)) { Type ifType = interfaceType.IsGenericType ? interfaceType.GetGenericTypeDefinition() : interfaceType; AssetIdentifier interfaceAssetId = AssetIdentifier.FromType(ifType); Asset interfaceAsset = new Asset(interfaceAssetId, ifType); if (!context.IsFiltered(interfaceAsset)) { var implElement = new XElement("implements"); ret.Add(implElement); GenerateTypeRef(context.Clone(implElement), interfaceType, "interface"); } } } } foreach (IEnricher enricher in this._enrichers) enricher.EnrichType(context.Clone(ret), type); context.Element.Add(ret); return ret; }
public static void GenerateTypeRef(IProcessingContext context, Type pType, string attrName = null) { // TODO rethink how we generate the typerefs, probably ensure we always output a root element rather than just the attribute for param/type if (pType.IsArray) { // TODO arrayOf is the only capitalized element var arrayElem = new XElement("arrayOf", new XAttribute("rank", pType.GetArrayRank())); context.Element.Add(arrayElem); GenerateTypeRef(context.Clone(arrayElem), pType.GetElementType()); } else { if (pType.IsGenericParameter) context.Element.Add(new XAttribute("param", pType.Name)); else if (pType.IsGenericType) { Type typeDefinition = pType.GetGenericTypeDefinition(); AssetIdentifier aid = AssetIdentifier.FromType(typeDefinition); context.AddReference(new Asset(aid, typeDefinition)); context.Element.Add(new XAttribute(attrName ?? "type", aid)); foreach (Type genArg in pType.GetGenericArguments()) { XElement argElem = new XElement("with"); GenerateTypeRef(context.Clone(argElem), genArg); context.Element.Add(argElem); } } else { AssetIdentifier aid = AssetIdentifier.FromMemberInfo(pType); context.AddReference(new Asset(aid, pType)); context.Element.Add(new XAttribute(attrName ?? "type", aid)); } } }
protected virtual void GenerateAttributeElements(IProcessingContext context, IEnumerable<CustomAttributeData> attrData) { foreach (CustomAttributeData custAttr in attrData) { Type originatingType = custAttr.Constructor.ReflectedType ?? custAttr.Constructor.DeclaringType; Asset typeAsset = ReflectionServices.GetAsset(originatingType); if (context.IsFiltered(typeAsset)) continue; Asset ctorAsset = ReflectionServices.GetAsset(custAttr.Constructor); context.AddReference(ctorAsset); var attrElem = new XElement("attribute", new XAttribute("type", typeAsset.Id), new XAttribute("constructor", ctorAsset.Id)); foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments) { XElement argElem = new XElement("argument"); this.GenerateValueLiteral(context.Clone(argElem), cta); attrElem.Add(argElem); } foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments) { Asset asset = ReflectionServices.GetAsset(cta.MemberInfo); context.AddReference(asset); XElement argElem = new XElement("argument", new XAttribute("member", asset.Id)); this.GenerateValueLiteral(context.Clone(argElem), cta.TypedValue); attrElem.Add(argElem); } context.Element.Add(attrElem); } }
private static IEnumerable<XObject> GenerateAttributeArgument(IProcessingContext context, CustomAttributeTypedArgument cata) { // TODO this needs to be cleaned up, and fixed context.AddReference(AssetIdentifier.FromMemberInfo(cata.ArgumentType)); yield return new XAttribute("type", AssetIdentifier.FromMemberInfo(cata.ArgumentType)); if (cata.ArgumentType.IsEnum) { if ( cata.ArgumentType.GetCustomAttributesData().Any( ca => ca.Constructor.DeclaringType == typeof(FlagsAttribute))) { string flags = Enum.ToObject(cata.ArgumentType, cata.Value).ToString(); string[] parts = flags.Split(','); yield return new XElement("literal", new XAttribute("value", cata.Value), Array.ConvertAll(parts, s => new XElement("flag", new XAttribute("value", s.Trim())))); } else { string value = Enum.GetName(cata.ArgumentType, cata.Value); if (value != null) yield return new XElement("literal", new XAttribute("value", value)); yield return new XElement("literal", new XAttribute("value", cata.Value)); } } else if (cata.ArgumentType == typeof(Type)) { XElement tmp = new XElement("tmp"); DocGenerator.GenerateTypeRef(context.Clone(tmp), (Type)cata.Value, "value"); yield return tmp.Attribute("value"); foreach (XElement xElement in tmp.Elements()) yield return xElement; } else // TODO fix how this encodes unprintable characters yield return new XAttribute("value", cata.Value.ToString().Replace("\0", "\\0")); }
// TODO fix this, and the accompanying XSLT template, the construction of attribute // arguments isn't very consitent private static void GenerateAttributeElements(IProcessingContext context, IEnumerable <CustomAttributeData> attrData) { foreach (CustomAttributeData custAttr in attrData) { AssetIdentifier typeAssetId = AssetIdentifier.FromMemberInfo(custAttr.Constructor.ReflectedType ?? custAttr.Constructor.DeclaringType); if (context.IsFiltered(typeAssetId)) { continue; } context.AddReference(AssetIdentifier.FromMemberInfo(custAttr.Constructor)); var attrElem = new XElement("attribute", new XAttribute("type", typeAssetId), new XAttribute("constructor", AssetIdentifier.FromMemberInfo(custAttr.Constructor))); foreach (CustomAttributeTypedArgument cta in custAttr.ConstructorArguments) { if (cta.Value is ReadOnlyCollection <CustomAttributeTypedArgument> ) { AssetIdentifier elementAssetId = AssetIdentifier.FromMemberInfo(cta.ArgumentType.GetElementType()); context.AddReference(elementAssetId); attrElem.Add(new XElement("argument", new XElement("array", new XAttribute("type", elementAssetId), ((IEnumerable <CustomAttributeTypedArgument>)cta.Value). Select( ata => new XElement("element", GenerateAttributeArgument( context, ata)))))); } else { attrElem.Add(new XElement("argument", GenerateAttributeArgument(context, cta))); } } foreach (CustomAttributeNamedArgument cta in custAttr.NamedArguments) { AssetIdentifier namedMember = AssetIdentifier.FromMemberInfo(cta.MemberInfo); context.AddReference(namedMember); if (cta.TypedValue.Value is ReadOnlyCollection <CustomAttributeTypedArgument> ) { context.AddReference(namedMember); AssetIdentifier elementAssetId = AssetIdentifier.FromMemberInfo(cta.TypedValue.ArgumentType.GetElementType()); context.AddReference(elementAssetId); attrElem.Add(new XElement("argument", new XAttribute("member", namedMember), new XElement("array", new XAttribute("type", elementAssetId), ((IEnumerable <CustomAttributeTypedArgument>) cta.TypedValue.Value).Select( ata => new XElement("element", GenerateAttributeArgument(context, ata)))))); } else { attrElem.Add(new XElement("argument", new XAttribute("member", namedMember), GenerateAttributeArgument(context, cta.TypedValue))); } } context.Element.Add(attrElem); } //using (var ms = new MemoryStream()) // context.Element.Save(ms); }