public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
TypeDefinition type = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary<FieldDefinition, PropertyDefinition> fieldToPropertyMap = type.GetFieldToPropertyMap(language);
IEnumerable<FieldDefinition> propertyFields = fieldToPropertyMap.Keys;
HashSet<PropertyDefinition> autoImplementedProperties = new HashSet<PropertyDefinition>(fieldToPropertyMap.Values);
HashSet<EventDefinition> autoImplementedEvents = GetAutoImplementedEvents(type);
TypeSpecificContext typeContext = new TypeSpecificContext(type) { AutoImplementedProperties = autoImplementedProperties, AutoImplementedEvents = autoImplementedEvents };
TypeDefinition declaringType = Utilities.GetDeclaringTypeOrSelf(member);
Dictionary<string, string> renamedNamespacesMap = new Dictionary<string, string>();
MemberRenamingData memberReanmingData = GetMemberRenamingData(declaringType.Module, language);
ModuleSpecificContext moduleContext =
new ModuleSpecificContext(declaringType.Module, new List<string>(), new Dictionary<string, List<string>>(), new Dictionary<string, HashSet<string>>(),
renamedNamespacesMap, memberReanmingData.RenamedMembers, memberReanmingData.RenamedMembersMap);
return new WriterContext(
new AssemblySpecificContext(),
moduleContext,
typeContext,
new Dictionary<string, MethodSpecificContext>(),
GetDecompiledStatements(member, language, propertyFields));
}
private static bool IsVisibleInSubclass(IMemberDefinition member)
{
//TODO! internal and in another assembly are also not visible!
// also take into account the InternalsVisibleTo attribute!
// and ProtectedANDInternal
if (member == null) return false;
var method = member as MethodDefinition;
if (method != null) {
return !method.IsPrivate;
}
var property = member as PropertyDefinition;
if (property != null) {
var getterIsVisible = IsVisibleInSubclass(property.GetMethod);
var setterIsVisible = IsVisibleInSubclass(property.SetMethod);
return getterIsVisible || setterIsVisible;
}
var @event = member as EventDefinition;
if (@event != null) {
var adderIsVisible = IsVisibleInSubclass(@event.AddMethod);
var removerIsVisible = IsVisibleInSubclass(@event.RemoveMethod);
var invokerIsVisible = IsVisibleInSubclass(@event.InvokeMethod);
return adderIsVisible || removerIsVisible || invokerIsVisible;
}
var field = member as FieldDefinition;
if (field != null) {
return !field.IsPrivate;
}
throw new InvalidOperationException();
}
/// <summary>
/// Creates the part of the member's ID string representation, following the prefix showing the kind of the member, according to ECMA-334 standart.
/// See chapter E: Documentation Comments.
/// </summary>
/// <param name="member"></param>
/// <returns></returns>
private string GetMemberFullName(IMemberDefinition member)
{
StringBuilder result = new StringBuilder();
if (member is TypeDefinition)
{
return GetTypeFullName(member as TypeDefinition);
}
else
{
// Every member, that is not a type, is supposed to have declaring type.
// As the specification is for the C# language, which does not allow methods to be declared outside of classes,
// global methods can't be documented using this format.
result.Append(GetTypeFullName(member.DeclaringType));
result.Append('.');
}
string memberName = member.Name.Replace('.', '#'); // according to the standart, '.' should be replaced with '#'
result.Append(memberName);
// Methods are the only members that can be generic (types are already handled).
if (member is MethodDefinition)
{
string genericMarker = GetMethodGenericParametersMarker(member as MethodDefinition);
result.Append(genericMarker);
}
if (member is MethodDefinition || member is PropertyDefinition)
{
string arguments = GetArgumentsString(member);
result.Append(arguments);
}
return result.ToString();
}
/// <summary>
/// Creates a new instance of this class.
/// </summary>
/// <param name="class">The member type.</param>
/// <param name="definition">The member definition.</param>
public TypeMember(TypeReference type, IMemberDefinition definition)
{
if (type == null) throw new ArgumentNullException("type");
if (definition == null) throw new ArgumentNullException("definition");
Type = type;
Definition = definition;
}
public IEnumerable<KeyValuePair<IMemberDefinition, string>> GetObjectsToRename(IMemberDefinition member)
{
//Returns ths given intem
yield return new KeyValuePair<IMemberDefinition, string>(member, "{0}");
//Checks if the member is a property or an event
if (member is PropertyDefinition)
{
var prop = (PropertyDefinition)member;
if (prop.GetMethod != null)
yield return new KeyValuePair<IMemberDefinition, string>(prop.GetMethod, "get_{0}");
if (prop.SetMethod != null)
yield return new KeyValuePair<IMemberDefinition, string>(prop.SetMethod, "set_{0}");
if (prop.HasOtherMethods)
foreach (var m in prop.OtherMethods)
yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
}
else if (member is EventDefinition)
{
var evt = (EventDefinition)member;
if (evt.AddMethod != null)
yield return new KeyValuePair<IMemberDefinition, string>(evt.AddMethod, "add_{0}");
if (evt.RemoveMethod != null)
yield return new KeyValuePair<IMemberDefinition, string>(evt.RemoveMethod, "remove_{0}");
if (evt.InvokeMethod != null)
yield return new KeyValuePair<IMemberDefinition, string>(evt.InvokeMethod, "raise_{0}");
if (evt.HasOtherMethods)
foreach (var m in evt.OtherMethods)
yield return new KeyValuePair<IMemberDefinition, string>(m, "{0}");
}
yield break;
}
/// <summary>
/// Rename a member definition
/// </summary>
/// <param name="imdef">Member definition</param>
/// <param name="name">new name</param>
public static void RenameMemberDefinition(IMemberDefinition imdef, string name)
{
if (imdef is TypeDefinition)
RenameTypeDefinition(imdef as TypeDefinition, name);
else
imdef.Name = name;
}
// LOOKUP Path.GetRandomFileName BaseBMethod
public string GetMemberName(IMemberDefinition member)
{
if (member.DeclaringType == null)
return GetTypeName((TypeDefinition)member);
var scopeId = GetMemberScope(member);
return GetNextName(scopeId);
}
/// <summary>
/// Gets the documentation related to <paramref name="member"/>. If no documentation is found for this particular member,
/// an empty string is returned.
/// </summary>
/// <param name="member"></param>
/// <returns>String containing the XML-formated documentation for <paramref name="member">.</returns>
public string GetDocumentationForMember(IMemberDefinition member)
{
string memberName = GetDocumentationMemberName(member);
if (documentationMap.ContainsKey(memberName))
{
return documentationMap[memberName];
}
return string.Empty;
}
public static string FormatMemberName(IMemberDefinition member)
{
var typePrefix = member.DeclaringType.Name + "_";
if (member.Name.Contains(typePrefix))
return EscapeIdentifier(member.Name);
else
return EscapeIdentifier(typePrefix + member.Name);
}
public override void WriteBody(IMemberDefinition member, IWriterContextService writerContextService)
{
this.writerContextService = writerContextService;
this.writerContext = writerContextService.GetWriterContext(member, Language);
this.currentWritingInfo = new WritingInfo(member);
UpdateWritingInfo(this.writerContext, this.currentWritingInfo);
this.writingInfos = new List<WritingInfo>();
this.writingInfos.Add(this.currentWritingInfo);
WriteBodyInternal(member);
}
protected CachedDecompiledMember AddDecompiledMemberToCache(IMemberDefinition member, DecompiledMember decompiledMember, TypeSpecificContext typeContext, ILanguage language)
{
CachedDecompiledMember cachedMember = new CachedDecompiledMember(decompiledMember, typeContext);
if (!this.cacheService.IsDecompiledMemberInCache(member, language, this.renameInvalidMembers))
{
this.cacheService.AddDecompiledMemberToCache(member, language, this.renameInvalidMembers, cachedMember);
}
return cachedMember;
}
/// <summary>
/// Initializes a new instance of the <see cref="StateInterceptor" /> class.
/// </summary>
/// <param name="memberDefinition">The method signature.</param>
/// <param name="callbacks">The callbacks.</param>
/// <exception cref="ArgumentNullException">The <paramref name="memberDefinition" /> is <c>null</c>.</exception>
/// <exception cref="ArgumentNullException">The <paramref name="callbacks" /> is <c>null</c>.</exception>
public StateInterceptor(IMemberDefinition memberDefinition, CallbackCollection callbacks)
{
Argument.IsNotNull("methodDefinition", memberDefinition);
Argument.IsNotNull("callbacks", callbacks);
MemberDefinition = memberDefinition;
CallbackCollection = callbacks;
_visitor = new SelectCallbackVisitor();
}
static void ProcessField(IMemberDefinition m)
{
foreach (CustomAttribute att in m.CustomAttributes)
if (att.Constructor.DeclaringType.Name == "ProcessingStandardFieldAttribute") {
var f = m as FieldDefinition;
if (f != null && f.IsLiteral)
Console.WriteLine ("Const " + m.Name);
else
Console.WriteLine ("Field " + m.Name);
}
}
/// <summary>
/// Generates the name, used to specify <paramref name="member"/> according to ECMA-334 standart.
/// </summary>
/// <param name="member">The member who's name is about to be generated.</param>
/// <returns>Returns the string used as ID in the documentation to refer to <paramref name="member">.</returns>
private string GetDocumentationMemberName(IMemberDefinition member)
{
StringBuilder sb = new StringBuilder();
string prefix = GetMemberPrefix(member);
sb.Append(prefix);
string memberFullname = GetMemberFullName(member);
sb.Append(memberFullname);
return sb.ToString();
}
//TODO Same fully-qualified type names in two assemblies http://msdn.microsoft.com/en-us/library/ms173212.aspx
private string MapMemberDefinition(IMemberDefinition member)
{
string newName = _codeProvider.CreateValidIdentifier(_nameGenerator.GetMemberName(member));
#if APPEND
DefinitionsMap[member] = member.Name + newName;
return member.Name + newName;
#else
DefinitionsMap[member] = newName;
return newName;
#endif
}
public virtual List<ICustomAttribute> CollectSecurityAttributes(IMemberDefinition member)
{
List<ICustomAttribute> attributes = new List<ICustomAttribute>();
if (member is ISecurityDeclarationMemberDefinition)
{
foreach (SecurityDeclaration securityDeclaration in (member as ISecurityDeclarationMemberDefinition).SecurityDeclarations)
{
attributes.AddRange(GetSecurityDeclaration(securityDeclaration));
}
}
return attributes;
}
public void CheckForNormalAttribute(IMemberDefinition memberDefinition)
{
var obsoleteExAttribute = memberDefinition
.CustomAttributes
.FirstOrDefault(x => x.AttributeType.Name == "ObsoleteAttribute");
if (obsoleteExAttribute == null)
{
return;
}
var warning = $"The member `{memberDefinition.FullName}` has an ObsoleteAttribute. You should consider replacing it with an ObsoleteExAttribute.";
LogWarning(warning);
}
void InnerProcess(IMemberDefinition memberDefinition)
{
var customAttributes = memberDefinition.CustomAttributes;
var obsoleteExAttribute = customAttributes.FirstOrDefault(x => x.AttributeType.Name == "ObsoleteExAttribute");
if (obsoleteExAttribute == null)
{
return;
}
var throwsNotImplemented = false;
var methodDefinition = memberDefinition as MethodDefinition;
if (methodDefinition != null)
{
throwsNotImplemented = ThrowsNotImplemented(methodDefinition);
if (methodDefinition.IsGetter || methodDefinition.IsSetter)
{
var error = $"ObsoleteExAttribute is not valid on property gets or sets. Member: `{memberDefinition.FullName}`.";
LogError(error);
}
}
else
{
var propertyDefinition = memberDefinition as PropertyDefinition;
if (propertyDefinition != null)
{
throwsNotImplemented = ThrowsNotImplemented(propertyDefinition);
}
}
customAttributes.Remove(obsoleteExAttribute);
var attributeData = DataReader.ReadAttributeData(obsoleteExAttribute, throwsNotImplemented);
try
{
ApplyVersionConvention(attributeData);
}
catch (WeavingException exception)
{
throw new WeavingException($"Could not process {memberDefinition.FullName}. {exception.Message}");
}
ValidateVersion(memberDefinition, attributeData);
AddObsoleteAttribute(attributeData, customAttributes);
if (HideObsoleteMembers)
{
AddEditorBrowsableAttribute(customAttributes);
}
}
// LOOKUP Path.GetRandomFileName BaseBMethod
public string GetMemberName(IMemberDefinition member)
{
if (member.DeclaringType == null)
return GetTypeName((TypeDefinition)member);
var declaringTypeName = GetDeclaringTypeName(member.DeclaringType);
string newName;
do{
newName = NewMethod(member);
}
while(newName == declaringTypeName);
//_scopedMemberNames[declaringTypeScope] = newName;
return newName;
}
public virtual void WriteMemberAttributesAndNewLine(IMemberDefinition member, IEnumerable<string> ignored = null, bool isWinRTImplementation = false)
{
//TODO Handle attributes that take arrays as arguments
//TODO write tests for all possible types of attribute values and targets
if (ignored != null)
{
foreach (string ignoredAttributeType in ignored)
{
attributesNotToShow.Add(ignoredAttributeType);
}
}
securityAttributeToDeclaration = new Dictionary<SecurityAttribute,SecurityDeclaration>();
List<ICustomAttribute> attributes = CollectSecurityAttributes(member);
foreach (CustomAttribute attribute in member.CustomAttributes)
{
attribute.Resolve();
if (!isWinRTImplementation || !IsWinRTActivatableAttribute(attribute))
{
attributes.Add(attribute);
}
}
attributes.AddRange(WritePropertiesAsAttributes(member));
attributes.Sort((x, y) => { return CompareAttributes(x, y); });
foreach (ICustomAttribute attribute in attributes)
{
if (attribute is CustomAttribute)
{
WriteAttribute(attribute as CustomAttribute);
}
else if (attribute is SecurityAttribute)
{
bool b;
WriteSecurityAttribute(GetModuleDefinition(member), false, attribute as SecurityAttribute, securityAttributeToDeclaration[attribute as SecurityAttribute], out b);
}
}
if (ignored!= null)
{
foreach (string ignoredAttributeType in ignored)
{
attributesNotToShow.Remove(ignoredAttributeType);
}
}
}
public WritingInfo(IMemberDefinition member)
{
this.Member = member;
this.StatementPositions = new Dictionary<ICodeNode, OffsetSpan>();
this.ControlFlowGraphs = new Dictionary<MethodDefinition, ControlFlowGraph>();
this.MethodsVariableDefinitionToNameMap = new Dictionary<MethodDefinition, Dictionary<VariableDefinition, string>>();
this.AutoImplementedProperties = new HashSet<PropertyDefinition>();
MemberDefinitionToFoldingPositionMap = new Dictionary<IMemberDefinition, OffsetSpan>();
this.ExceptionsWhileWriting = new HashSet<IMemberDefinition>();
this.AutoImplementedEvents = new HashSet<EventDefinition>();
this.MemberDeclarationToCodePostionMap = new Dictionary<IMemberDefinition, OffsetSpan>();
this.MemberTokenToAttributesMap = new Dictionary<uint, OffsetSpan>();
this.MemberTokenToDocumentationMap = new Dictionary<uint, OffsetSpan>();
this.MemberTokenToDecompiledCodeMap = new Dictionary<uint, OffsetSpan>();
this.MembersWithExceptions = new HashSet<uint>();
this.GeneratedFilterMethods = new List<MethodDefinition>();
}
public override WriterContext GetWriterContext(IMemberDefinition member, ILanguage language)
{
AssemblySpecificContext assemblyContext = new AssemblySpecificContext();
ModuleSpecificContext moduleContext = new ModuleSpecificContext();
TypeSpecificContext typeContext = new TypeSpecificContext(Utilities.GetDeclaringTypeOrSelf(member));
DecompiledType decompiledType = GetDecompiledType(member, language);
Dictionary<string, MethodSpecificContext> methodContexts = new Dictionary<string, MethodSpecificContext>();
Dictionary<string, Statement> decompiledStatements = new Dictionary<string, Statement>();
foreach (KeyValuePair<string, DecompiledMember> decompiledPair in decompiledType.DecompiledMembers)
{
methodContexts.Add(decompiledPair.Key, decompiledPair.Value.Context);
decompiledStatements.Add(decompiledPair.Key, decompiledPair.Value.Statement);
}
WriterContext writerContext = new WriterContext(assemblyContext, moduleContext, typeContext, methodContexts, decompiledStatements);
return writerContext;
}
public virtual bool IsDecompiledMemberInCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers)
{
bool isDecompiledMemberInCache = decompiledMembersCache.ContainsKey(GetMemberKey(member, language, renameInvalidMembers));
if (isDecompiledMemberInCache)
{
CachedDecompiledMember cachedDecompiledMember = this.GetDecompiledMemberFromCache(member, language, renameInvalidMembers);
foreach (CastExpression cast in cachedDecompiledMember.Member.Context.AnalysisResults.AmbiguousCastsToObject)
{
TypeReference lastResolvedType;
bool? haveOverloadedOperator = Common.Extensions.ResolveToOverloadedEqualityOperator(cast.Expression.ExpressionType, out lastResolvedType);
bool isResolved = haveOverloadedOperator.HasValue;
if (isResolved)
{
this.RemoveDecompiledMemberFromCache(member, language, renameInvalidMembers);
isDecompiledMemberInCache = false;
break;
}
}
}
return isDecompiledMemberInCache;
}
private DecompiledType GetDecompiledType(IMemberDefinition member, ILanguage language)
{
TypeDefinition declaringType = member is TypeDefinition ? member as TypeDefinition : member.DeclaringType;
DecompiledType decompiledType = new DecompiledType(declaringType);
if (member is MethodDefinition)
{
MethodDefinition method = member as MethodDefinition;
DecompiledMember decompiledMember = Utilities.TryGetDecompiledMember(method, decompiledType.TypeContext, language);
decompiledType.DecompiledMembers.Add(method.FullName, decompiledMember);
}
else if (member is PropertyDefinition)
{
PropertyDefinition propertyDefinition = (member as PropertyDefinition);
if (propertyDefinition.GetMethod != null)
{
DecompiledMember decompiledMember = Utilities.TryGetDecompiledMember(propertyDefinition.GetMethod, decompiledType.TypeContext, language);
decompiledType.DecompiledMembers.Add(propertyDefinition.GetMethod.FullName, decompiledMember);
}
if (propertyDefinition.SetMethod != null)
{
DecompiledMember decompiledMember = Utilities.TryGetDecompiledMember(propertyDefinition.SetMethod, decompiledType.TypeContext, language);
decompiledType.DecompiledMembers.Add(propertyDefinition.SetMethod.FullName, decompiledMember);
}
}
else
{
throw new NotSupportedException("FrameworkFolderWriterContext service supports only methods and properties.");
}
AddGeneratedFilterMethodsToDecompiledType(decompiledType, decompiledType.TypeContext, language);
return decompiledType;
}
private int SortEnumFields(IMemberDefinition first, IMemberDefinition second)
{
FieldDefinition firstField = first as FieldDefinition;
FieldDefinition secondField = second as FieldDefinition;
if (firstField == null || firstField.Constant == null || firstField.Constant.Value == null)
{
return(1);
}
if (secondField == null || secondField.Constant == null || secondField.Constant.Value == null)
{
return(-1);
}
//return firstField.Constant.ToString().CompareTo(secondField.Constant.ToString());
int valuesCompared = 0;
if (firstField.Constant.Value.GetType().Name == "Int32")
{
int firstFieldValue = (int)firstField.Constant.Value;
int secondFieldValue = (int)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
if (firstField.Constant.Value.GetType().Name == "UInt32")
{
uint firstFieldValue = (uint)firstField.Constant.Value;
uint secondFieldValue = (uint)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "Int16")
{
short firstFieldValue = (short)firstField.Constant.Value;
short secondFieldValue = (short)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "UInt16")
{
ushort firstFieldValue = (ushort)firstField.Constant.Value;
ushort secondFieldValue = (ushort)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "Byte")
{
byte firstFieldValue = (byte)firstField.Constant.Value;
byte secondFieldValue = (byte)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "SByte")
{
sbyte firstFieldValue = (sbyte)firstField.Constant.Value;
sbyte secondFieldValue = (sbyte)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "Int64")
{
long firstFieldValue = (long)firstField.Constant.Value;
long secondFieldValue = (long)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
else if (firstField.Constant.Value.GetType().Name == "UInt64")
{
ulong firstFieldValue = (ulong)firstField.Constant.Value;
ulong secondFieldValue = (ulong)secondField.Constant.Value;
valuesCompared = firstFieldValue.CompareTo(secondFieldValue);
}
if (valuesCompared != 0)
{
return(valuesCompared);
}
return(firstField.Name.CompareTo(secondField.Name));
}
public ConstSpec(TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo fi, Modifiers mod, Expression value)
: base(declaringType, definition, memberType, fi, mod)
{
this.value = value;
}
protected override bool MatchName(IMemberDefinition m, Language language)
{
return(m.MetadataToken.ToInt32() == searchTermToken);
}
public override void WriteLine(IMemberDefinition member, bool isHidden)
{
string docId = DocCommentId.GetDocCommentId(member);
string baseType = string.Empty;
string declType = string.Empty;
string declNamespace = string.Empty;
string retType = string.Empty;
string constValue = string.Empty;
bool isStatic = false;
var typeDef = member as TypeDefinition;
if (typeDef != null)
{
baseType = typeDef.BaseType?.FullName;
declNamespace = typeDef.Namespace;
}
if (member.DeclaringType != null)
{
declType = member.DeclaringType.FullName;
declNamespace = member.DeclaringType.Namespace;
}
var methodDef = member as MethodDefinition;
if (methodDef != null)
{
retType = methodDef.ReturnType.FullName;
isStatic = methodDef.IsStatic;
}
var eventDef = member as EventDefinition;
if (eventDef != null)
{
retType = eventDef.EventType.FullName;
}
var propDef = member as PropertyDefinition;
if (propDef != null)
{
retType = propDef.PropertyType.FullName;
}
var fieldDef = member as FieldDefinition;
if (fieldDef != null)
{
retType = fieldDef.FieldType.FullName;
constValue = fieldDef.Constant?.ToString();
isStatic = fieldDef.IsStatic;
}
string sinceTizen = string.Empty;
List <string> privileges = new List <string>();
List <string> features = new List <string>();
XmlNode xmlNode = _asmDoc.GetMemberNode(docId);
if (xmlNode != null)
{
foreach (XmlNode childNode in xmlNode)
{
if (childNode.Name == "privilege")
{
privileges.AddRange(Regex.Split(childNode.InnerText.Trim(), @"\s+"));
}
else if (childNode.Name == "feature")
{
features.AddRange(Regex.Split(childNode.InnerText.Trim(), @"\s+"));
}
else if (childNode.Name == "since_tizen")
{
sinceTizen = childNode.InnerText.Trim();
}
}
privileges.Sort();
features.Sort();
}
if (!_isFirstMember)
{
Writer.WriteLine(",");
}
_isFirstMember = false;
Writer.WriteLine(" {");
Writer.WriteLine(" \"DocId\": \"{0}\",", docId);
Writer.WriteLine(" \"Info\": {");
Writer.WriteLine(" \"Signature\": \"{0}\",", member.FullName);
if (!string.IsNullOrEmpty(baseType))
{
Writer.WriteLine(" \"BaseType\": \"{0}\",", baseType);
}
if (!string.IsNullOrEmpty(declType))
{
Writer.WriteLine(" \"DeclaringType\": \"{0}\",", declType);
}
if (!string.IsNullOrEmpty(declNamespace))
{
Writer.WriteLine(" \"Namespace\": \"{0}\",", declNamespace);
}
if (!string.IsNullOrEmpty(retType))
{
Writer.WriteLine(" \"ReturnType\": \"{0}\",", retType);
}
if (!string.IsNullOrEmpty(constValue))
{
Writer.WriteLine(" \"Constant\": \"{0}\",", constValue);
}
Writer.WriteLine(" \"IsStatic\": {0},", isStatic ? "true" : "false");
Writer.WriteLine(" \"IsHidden\": {0},", isHidden ? "true" : "false");
Writer.WriteLine(" \"IsObsolete\": {0},", IsObsoleteMember(member) ? "true" : "false");
if (string.IsNullOrEmpty(sinceTizen))
{
sinceTizen = "none";
}
Writer.WriteLine(" \"Since\": \"{0}\"{1}", sinceTizen, (privileges.Count + features.Count > 0) ? "," : string.Empty);
if (privileges.Count > 0)
{
Writer.WriteLine(" \"Privileges\": [");
for (var i = 0; i < privileges.Count; i++)
{
Writer.WriteLine(" \"{0}\"{1}", privileges[i], i < privileges.Count - 1 ? "," : string.Empty);
}
Writer.WriteLine(" ]{0}", features.Count > 0 ? "," : string.Empty);
}
if (features.Count > 0)
{
Writer.WriteLine(" \"Features\": [");
for (var i = 0; i < features.Count; i++)
{
Writer.WriteLine(" \"{0}\"{1}", features[i], i < features.Count - 1 ? "," : string.Empty);
}
Writer.WriteLine(" ]");
}
Writer.WriteLine(" }");
Writer.Write(" }");
Writer.Flush();
}
public static string GetMemberUniqueName(IMemberDefinition member)
{
if (member is MethodDefinition)
{
MethodDefinition method = member as MethodDefinition;
string name = method.FullName;
if (method.HasGenericParameters)
{
foreach (GenericParameter genericParameter in method.GenericParameters)
{
name = name + genericParameter.Name;
if (genericParameter.HasConstraints || genericParameter.HasDefaultConstructorConstraint ||
genericParameter.HasReferenceTypeConstraint || genericParameter.HasNotNullableValueTypeConstraint)
{
bool wroteConstraint = false;
if (genericParameter.HasNotNullableValueTypeConstraint)
{
if (wroteConstraint)
{
name = name + ", ";
}
wroteConstraint = true;
name = name + "struct";
}
foreach (TypeReference constraint in genericParameter.Constraints)
{
if (genericParameter.HasNotNullableValueTypeConstraint && constraint.FullName == "System.ValueType")
{
continue;
}
if (wroteConstraint)
{
name = name + ", ";
}
name = name + constraint.FullName;
wroteConstraint = true;
}
if (genericParameter.HasReferenceTypeConstraint)
{
if (wroteConstraint)
{
name = name + ", ";
}
wroteConstraint = true;
name = name + "class";
}
if (genericParameter.HasDefaultConstructorConstraint && !genericParameter.HasNotNullableValueTypeConstraint)
{
if (wroteConstraint)
{
name = name + ", ";
}
wroteConstraint = true;
name = name + "new()";
}
}
}
}
return(name);
}
else
{
return(member.FullName);
}
}
protected virtual void WriteAttributes(IMemberDefinition member, IEnumerable <string> ignoredAttributes = null)
{
}
public bool IsDecompiledMemberInCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers)
{
return(false);
}
/// <summary>
/// Create a warning message.
/// </summary>
/// <param name="context">Context with the relevant warning suppression info.</param>
/// <param name="text">Humanly readable message describing the warning</param>
/// <param name="code">Unique warning ID. Please see https://github.com/mono/linker/blob/master/doc/error-codes.md
/// for the list of warnings and possibly add a new one</param>
/// /// <param name="origin">Type or member where the warning is coming from</param>
/// <param name="subcategory">Optionally, further categorize this warning</param>
/// <returns>New MessageContainer of 'Warning' category</returns>
internal static MessageContainer CreateWarningMessage(LinkContext context, string text, int code, IMemberDefinition origin, string subcategory = MessageSubCategory.None)
{
MessageOrigin _origin = new MessageOrigin(origin);
return(CreateWarningMessage(context, text, code, _origin, subcategory));
}
protected void AddHelper(IMemberDefinition helper, HelperAttribute attr)
{
cr.helpers.Add(helper, attr);
}
public FieldSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo info, Modifiers modifiers)
: base (MemberKind.Field, declaringType, definition, modifiers)
{
this.metaInfo = info;
this.memberType = memberType;
}
public bool ShouldWarnWhenAccessedForReflection(IMemberDefinition provider) =>
provider switch
{
public IndexerSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, AParametersCollection parameters, PropertyInfo info, Modifiers modifiers)
: base (MemberKind.Indexer, declaringType, definition, memberType, info, modifiers)
{
this.parameters = parameters;
}
public PropertySpec (MemberKind kind, TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, PropertyInfo info, Modifiers modifiers)
: base (kind, declaringType, definition, modifiers)
{
this.info = info;
this.memberType = memberType;
}
protected virtual bool MatchName(IMemberDefinition m, Language language)
{
return(IsMatch(t => GetLanguageSpecificName(language, m, regex != null ? fullNameSearch : t.Contains("."))));
}
protected virtual void WriteInternal(IMemberDefinition member)
{
uint memberToken = member.MetadataToken.ToUInt32();
if (isStopped)
{
return;
}
membersStack.Push(member);
bool isNestedType = member is TypeDefinition && member != this.CurrentType;
if (!isNestedType)
{
formatter.PreserveIndent(member);
}
try
{
if (this.Settings.WriteDocumentation && !isNestedType)
{
int documentationStartIndex = this.formatter.CurrentPosition;
WriteDocumentation(member);
AddMemberDocumentationOffsetSpan(memberToken, documentationStartIndex, this.formatter.CurrentPosition);
}
if (member is TypeDefinition)
{
formatter.WriteMemberDeclaration(member);
WriteTypeInANewWriterIfNeeded((TypeDefinition)member);
}
else
{
int attributesStartIndex = this.formatter.CurrentPosition;
WriteAttributes(member);
AddMemberAttributesOffsetSpan(memberToken, attributesStartIndex, this.formatter.CurrentPosition);
int decompiledCodeStartIndex = this.formatter.CurrentPosition;
if (member is MethodDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((MethodDefinition)member);
}
else if (member is PropertyDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((PropertyDefinition)member);
}
else if (member is EventDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((EventDefinition)member);
}
else if (member is FieldDefinition)
{
formatter.WriteMemberDeclaration(member);
Write((FieldDefinition)member);
}
this.currentWritingInfo.MemberTokenToDecompiledCodeMap.Add(memberToken, new OffsetSpan(decompiledCodeStartIndex, this.formatter.CurrentPosition - 1));
}
}
catch (Exception ex)
{
ExceptionStatement exceptionStatement = new ExceptionStatement(ex, member);
Visit(exceptionStatement);
formatter.RestoreIndent(member);
this.currentWritingInfo.ExceptionsWhileWriting.Add(member);
this.currentWritingInfo.MembersWithExceptions.Add(memberToken);
if (member is PropertyDefinition)
{
PropertyDefinition property = member as PropertyDefinition;
if (property.GetMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(property.GetMethod);
}
if (property.SetMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(property.SetMethod);
}
}
if (member is EventDefinition)
{
EventDefinition @event = member as EventDefinition;
if (@event.AddMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.AddMethod);
}
if (@event.RemoveMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.RemoveMethod);
}
if (@event.InvokeMethod != null)
{
this.currentWritingInfo.ExceptionsWhileWriting.Add(@event.InvokeMethod);
}
}
OnExceptionThrown(ex);
}
if (!(member is TypeDefinition) || (member == CurrentType))
{
formatter.RemovePreservedIndent(member);
}
membersStack.Pop();
}
/// <summary>
/// Display a warning message to the end user.
/// This API is used for warnings defined in the linker, not by custom steps. Warning
/// versions are inferred from the code, and every warning that we define is versioned.
/// </summary>
/// <param name="text">Humanly readable message describing the warning</param>
/// <param name="code">Unique warning ID. Please see https://github.com/mono/linker/blob/master/doc/error-codes.md for the list of warnings and possibly add a new one</param>
/// <param name="origin">Type or member where the warning is coming from</param>
/// <param name="subcategory">Optionally, further categorize this warning</param>
/// <returns>New MessageContainer of 'Warning' category</returns>
public void LogWarning(string text, int code, IMemberDefinition origin, int?ilOffset = null, string subcategory = MessageSubCategory.None)
{
MessageOrigin _origin = new MessageOrigin(origin, ilOffset);
LogWarning(text, code, _origin, subcategory);
}
protected virtual void WriteBodyInternal(IMemberDefinition member)
{
}
public virtual string GetExplicitName(IMemberDefinition member)
{
return(member.Name);
}
public static void IgnoreMember(IMemberDefinition memberInfo)
{
ignoredMembers.Add(memberInfo);
}
private static bool IsCompilerGenerated(IMemberDefinition m)
{
return(m.CustomAttributes.Any(a => a.AttributeType.FullName == "System.Runtime.CompilerServices.CompilerGeneratedAttribute"));
}
public CachedDecompiledMember GetDecompiledMemberFromCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers)
{
throw new NotSupportedException("ProjectGenerationDecompilationCacheServices caches only full nested decompiled types.");
}
/// <summary>
/// Finds the state interceptor by method signature.
/// </summary>
/// <param name="definition">The signature.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">The <paramref name="definition"/> is <c>null</c>.</exception>
private StateInterceptor FindStateInterceptorByMemberDefinition(IMemberDefinition definition)
{
Argument.IsNotNull(() => definition);
return(StateInterceptorCollection.FirstOrDefault(interceptor => interceptor.MemberDefinition.Equals(definition)));
}
public static TypeDefinition GetDeclaringTypeOrSelf(IMemberDefinition member)
{
return(member is TypeDefinition ? member as TypeDefinition : member.DeclaringType);
}
public virtual string GetExplicitName(IMemberDefinition member)
{
return member.get_Name();
}
public override bool IsApplicableFor(IMemberDefinition target)
{
//check args
return(base.IsApplicableFor(target));
}
public void AddDecompiledMemberToCache(IMemberDefinition member, ILanguage language, bool renameInvalidMembers, CachedDecompiledMember decompiledMember)
{
return;
}
public override void WriteMemberAttributesAndNewLine(IMemberDefinition member, IEnumerable <string> ignored = null, bool isWinRTImplementation = false)
{
base.WriteMemberAttributesAndNewLine(member,
member is TypeDefinition ? AddExtensionAttributeToIgnored(ignored) : ignored,
isWinRTImplementation);
}
private static string GetFullName(this IMemberDefinition method)
{
return($"{method.DeclaringType.Name}.{method.Name}");
}
IEnumerable <ExportAttribute> GetExportAttributes(IMemberDefinition p)
{
return(GetAttributes <ExportAttribute> (p, a => ToExportAttribute(a, p)));
}
private static bool ShouldIncludeMember(IMemberDefinition m)
{
return(!IsCompilerGenerated(m) && !IsDotNetTypeMember(m) && !(m is FieldDefinition));
}
public EventSpec (TypeSpec declaringType, IMemberDefinition definition, TypeSpec eventType, Modifiers modifiers, MethodSpec add, MethodSpec remove)
: base (MemberKind.Event, declaringType, definition, modifiers)
{
this.AccessorAdd = add;
this.AccessorRemove = remove;
this.MemberType = eventType;
}
public virtual string GetDefinitionName(IEmitter emitter, IMemberDefinition member, bool preserveMemberCase = false)
{
if (!preserveMemberCase)
{
preserveMemberCase = !this.IsNativeMember(member.FullName) ? this.AssemblyInfo.PreserveMemberCase : false;
if (member is FieldDefinition && ((FieldDefinition)member).HasConstant && !member.DeclaringType.IsEnum)
{
preserveMemberCase = true;
}
}
string attrName = Bridge.Translator.Translator.Bridge_ASSEMBLY + ".NameAttribute";
var attr = Helpers.GetInheritedAttribute(emitter, member, attrName);
bool isIgnore = this.Validator.IsIgnoreType(member.DeclaringType);
string name = member.Name;
bool isStatic = false;
if (member is MethodDefinition)
{
var method = (MethodDefinition)member;
isStatic = method.IsStatic;
if (method.IsConstructor)
{
name = JS.Funcs.CONSTRUCTOR;
}
}
else if (member is FieldDefinition)
{
isStatic = ((FieldDefinition)member).IsStatic;
}
else if (member is PropertyDefinition)
{
var prop = (PropertyDefinition)member;
isStatic = prop.GetMethod != null ? prop.GetMethod.IsStatic : false;
}
else if (member is EventDefinition)
{
var ev = (EventDefinition)member;
isStatic = ev.AddMethod != null ? ev.AddMethod.IsStatic : false;
}
if (attr != null)
{
var value = attr.ConstructorArguments.First().Value;
if (value is string)
{
name = value.ToString();
if (!isIgnore &&
((isStatic && Emitter.IsReservedStaticName(name)) /*||
* Helpers.IsReservedWord(name)*/))
{
name = Helpers.ChangeReservedWord(name);
}
return(name);
}
preserveMemberCase = !(bool)value;
}
if (name.Contains("."))
{
name = Object.Net.Utilities.StringUtils.RightOfRightmostOf(name, '.');
}
if (name.Length > 1 && name.ToUpperInvariant() == name)
{
preserveMemberCase = true;
}
name = preserveMemberCase ? name : Object.Net.Utilities.StringUtils.ToLowerCamelCase(name);
if (!isIgnore &&
((isStatic && Emitter.IsReservedStaticName(name)) /*||
* Helpers.IsReservedWord(name)*/))
{
name = Helpers.ChangeReservedWord(name);
}
return(name);
}
/// <summary>
/// Finds the state interceptor by method signature.
/// </summary>
/// <param name="definition">The signature.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">The <paramref name="definition"/> is <c>null</c>.</exception>
private StateInterceptor FindStateInterceptorByMemberDefinition(IMemberDefinition definition)
{
Argument.IsNotNull(() => definition);
return StateInterceptorCollection.FirstOrDefault(interceptor => interceptor.MemberDefinition.Equals(definition));
}
public static bool IsDefined(this IMemberDefinition member, TypeReference attributeType)
{
return(member.HasCustomAttributes && member.CustomAttributes.Any(x => x.AttributeType.FullName == attributeType.FullName));
}
public FixedFieldSpec (TypeSpec declaringType, IMemberDefinition definition, FieldInfo info, FieldSpec element, Modifiers modifiers)
: base (declaringType, definition, element.MemberType, info, modifiers)
{
this.element = element;
// It's never CLS-Compliant
state &= ~StateFlags.CLSCompliant_Undetected;
}
public FieldSpec(TypeSpec declaringType, IMemberDefinition definition, TypeSpec memberType, FieldInfo info, Modifiers modifiers)
: base(MemberKind.Field, declaringType, definition, modifiers)
{
this.metaInfo = info;
this.memberType = memberType;
}
