public static ITypeDefinition GetHiddenBaseType(this ITypeDefinition type, ICciFilter filter = null)
{
if (!(type is INestedTypeDefinition nestedType))
{
return(Dummy.Type);
}
ITypeDefinition containingType = nestedType.ContainingTypeDefinition;
foreach (ITypeReference baseClassRef in containingType.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (ITypeDefinition baseType in baseClass.GetMembersNamed(nestedType.Name, ignoreCase: false).OfType <ITypeDefinition>())
{
if (baseType.GetVisibility() == TypeMemberVisibility.Private)
{
continue;
}
if (IsAssembly(baseType) && !InSameUnit(baseType, nestedType))
{
continue;
}
if (filter != null && !filter.Include(baseType))
{
continue;
}
return(baseType);
}
}
return(Dummy.Type);
}
public override void Visit(IAssembly assembly)
{
_declarationWriter.ModuleNullableContextValue = assembly.ModuleAttributes.GetCustomAttributeArgumentValue <byte?>(CSharpCciExtensions.NullableContextAttributeFullName);
if (_writeAssemblyAttributes)
{
_declarationWriter.WriteDeclaration(assembly);
}
var namespaces = assembly.GetAllNamespaces();
_currentTypeListFilter = null;
// first pass, visit types *not* mentioned in ConditionalTypeLists
WriteConditionStart(DefaultCondition);
Visit(namespaces);
WriteConditionEnd(DefaultCondition);
// second pass, visit types mentioned in ConditionalTypeLists
foreach (var typeList in ConditionalTypeLists ?? Enumerable.Empty <ConditionalTypeList>())
{
_currentTypeListFilter = typeList.Filter;
WriteConditionStart(typeList.Symbol);
Visit(namespaces.Where(_currentTypeListFilter.Include));
WriteConditionEnd(typeList.Symbol);
}
}
public DependencyTraverser(ICciFilter filter)
: base(filter)
{
_dependencies = new Dictionary <IDefinition, HashSet <IReference> >(new ReferenceEqualityComparer <IDefinition>());
_definitionStack = new Stack <IDefinition>();
_unresolvedDependencies = new HashSet <IReference>(new ReferenceEqualityComparer <IReference>());
}
private static ICciWriter GetWriter(TextWriter output, IStyleSyntaxWriter syntaxWriter)
{
ICciFilter filter = GetFilter();
switch (s_writer)
{
case WriterType.DocIds:
return(new DocumentIdWriter(output, filter));
case WriterType.TypeForwards:
return(new TypeForwardWriter(output, filter));
case WriterType.TypeList:
return(new TypeListWriter(syntaxWriter, filter));
default:
case WriterType.CSDecl:
{
CSharpWriter writer = new CSharpWriter(syntaxWriter, filter, s_apiOnly);
writer.IncludeSpaceBetweenMemberGroups = writer.IncludeMemberGroupHeadings = s_memberHeadings;
writer.HighlightBaseMembers = s_hightlightBaseMembers;
writer.HighlightInterfaceMembers = s_hightlightInterfaceMembers;
writer.PutBraceOnNewLine = true;
writer.ThrowPlatformNotSupportedForCompilation = s_throw;
return(writer);
}
}
}
private static ICciFilter GetFilter(string apiList, bool all, bool apiOnly, string excludeApiList, bool excludeMembers, string excludeAttributesList)
{
ICciFilter includeFilter = null;
if (string.IsNullOrWhiteSpace(apiList))
{
if (all)
{
includeFilter = new IncludeAllFilter();
}
else
{
includeFilter = new PublicOnlyCciFilter(excludeAttributes: apiOnly);
}
}
else
{
includeFilter = new DocIdIncludeListFilter(apiList);
}
if (!string.IsNullOrWhiteSpace(excludeApiList))
{
includeFilter = new IntersectionFilter(includeFilter, new DocIdExcludeListFilter(excludeApiList, excludeMembers));
}
if (!string.IsNullOrWhiteSpace(excludeAttributesList))
{
includeFilter = new IntersectionFilter(includeFilter, new ExcludeAttributesFilter(excludeAttributesList));
}
return(includeFilter);
}
private static ICciWriter GetWriter(TextWriter output, IStyleSyntaxWriter syntaxWriter)
{
ICciFilter filter = GetFilter();
switch (s_writer)
{
case WriterType.DocIds:
return(new DocumentIdWriter(output, filter, s_docIdKind));
case WriterType.TypeForwards:
return(new TypeForwardWriter(output, filter)
{
IncludeForwardedTypes = true
});
case WriterType.TypeList:
return(new TypeListWriter(syntaxWriter, filter));
default:
case WriterType.CSDecl:
{
CSharpWriter writer = new CSharpWriter(syntaxWriter, filter, s_apiOnly);
writer.IncludeSpaceBetweenMemberGroups = writer.IncludeMemberGroupHeadings = s_memberHeadings;
writer.HighlightBaseMembers = s_hightlightBaseMembers;
writer.HighlightInterfaceMembers = s_hightlightInterfaceMembers;
writer.PutBraceOnNewLine = true;
writer.PlatformNotSupportedExceptionMessage = s_exceptionMessage;
writer.IncludeGlobalPrefixForCompilation = s_global;
writer.AlwaysIncludeBase = s_alwaysIncludeBase;
return(writer);
}
}
}
private static ICciFilter GetFilter()
{
ICciFilter includeFilter = null;
if (string.IsNullOrWhiteSpace(s_apiList))
{
if (s_all)
{
includeFilter = new IncludeAllFilter();
}
else
{
includeFilter = new PublicOnlyCciFilter(excludeAttributes: s_apiOnly);
}
}
else
{
includeFilter = new DocIdIncludeListFilter(s_apiList);
}
if (!string.IsNullOrWhiteSpace(s_excludeApiList))
{
includeFilter = new IntersectionFilter(includeFilter, new DocIdExcludeListFilter(s_excludeApiList));
}
if (!string.IsNullOrWhiteSpace(s_excludeAttributesList))
{
includeFilter = new IntersectionFilter(includeFilter, new ExcludeAttributesFilter(s_excludeAttributesList));
}
return(includeFilter);
}
public CSharpWriter(ISyntaxWriter writer, ICciFilter filter, bool apiOnly, bool writeAssemblyAttributes = false)
: base(filter)
{
_syntaxWriter = writer;
_styleWriter = writer as IStyleSyntaxWriter;
_declarationWriter = new CSDeclarationWriter(_syntaxWriter, filter, !apiOnly);
_writeAssemblyAttributes = writeAssemblyAttributes;
}
public CSharpWriter(ISyntaxWriter writer, ICciFilter filter, bool apiOnly, bool writeAssemblyAttributes = false)
: base(filter)
{
_syntaxWriter = writer;
_styleWriter = writer as IStyleSyntaxWriter;
_declarationWriter = new CSDeclarationWriter(_syntaxWriter, filter, !apiOnly);
_writeAssemblyAttributes = writeAssemblyAttributes;
}
public CSDeclarationWriter(ISyntaxWriter writer, ICciFilter filter, bool forCompilation)
{
Contract.Requires(writer != null);
_writer = writer;
_filter = filter;
_forCompilation = forCompilation;
_forCompilationIncludeGlobalprefix = false;
_includeFakeAttributes = false;
}
public static ICciFilter Not(this ICciFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
return(new NegatedFilter(filter));
}
public CSDeclarationWriter(ISyntaxWriter writer, ICciFilter filter, bool forCompilation)
{
Contract.Requires(writer != null);
_writer = writer;
_filter = filter;
_forCompilation = forCompilation;
_forCompilationIncludeGlobalprefix = false;
_platformNotSupportedExceptionMessage = null;
_includeFakeAttributes = false;
_alwaysIncludeBase = false;
}
public static ICciFilter And(this ICciFilter left, ICciFilter right)
{
if (left == null)
{
throw new ArgumentNullException(nameof(left));
}
if (right == null)
{
throw new ArgumentNullException(nameof(right));
}
return(new AndFilter(left, right));
}
public SimpleTypeMemberTraverser(ICciFilter filter)
{
_filter = filter ?? new IncludeAllFilter();
}
public TypeForwardWriter(TextWriter writer, ICciFilter filter)
: base(filter)
{
_writer = writer;
}
public DocumentIdWriter(TextWriter writer, ICciFilter filter)
: base(filter)
{
_writer = writer;
}
public TypesOnlyMappingDifferenceFilter(Func<DifferenceType, bool> include, ICciFilter filter)
: base(include, filter)
{
}
public TypeListWriter(ISyntaxWriter writer, ICciFilter filter)
: base(filter)
{
_syntaxWriter = writer;
_declarationWriter = new CSDeclarationWriter(_syntaxWriter, filter, false);
}
private static IMappingDifferenceFilter GetDiffFilter(ICciFilter filter)
{
return(new MappingDifferenceFilter(GetIncludeFilter(), filter));
}
public CSDeclarationHelper(ICciFilter filter, bool forCompilation = false, bool includePseudoCustomAttributes = false)
{
_filter = filter;
_forCompilation = forCompilation;
_includeFakeAttributes = includePseudoCustomAttributes;
}
public CSDeclarationHelper(ICciFilter filter, bool forCompilation = false, bool includePseudoCustomAttributes = false)
{
_filter = filter;
_forCompilation = forCompilation;
_includeFakeAttributes = includePseudoCustomAttributes;
}
public static IEventDefinition GetHiddenBaseEvent(this IEventDefinition evnt, ICciFilter filter = null)
{
IMethodDefinition eventRep = evnt.Adder.ResolvedMethod;
if (eventRep.IsVirtual && !eventRep.IsNewSlot) return Dummy.Event; // an override
foreach (ITypeReference baseClassRef in evnt.ContainingTypeDefinition.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IEventDefinition baseEvent in baseClass.GetMembersNamed(evnt.Name, false).OfType<IEventDefinition>())
{
if (baseEvent.Visibility == TypeMemberVisibility.Private) continue;
if (IsAssembly(baseEvent) && !InSameUnit(baseEvent, evnt))
continue;
if (filter != null && !filter.Include(baseEvent))
continue;
return baseEvent;
}
}
return Dummy.Event;
}
public MappingDifferenceFilter(Func <DifferenceType, bool> include, ICciFilter filter)
{
_include = include;
_filter = filter;
}
public static IPropertyDefinition GetHiddenBaseProperty(this IPropertyDefinition property, ICciFilter filter = null)
{
IMethodDefinition propertyRep = property.Accessors.First().ResolvedMethod;
if (propertyRep.IsVirtual && !propertyRep.IsNewSlot) return Dummy.Property; // an override
ITypeDefinition type = property.ContainingTypeDefinition;
foreach (ITypeReference baseClassRef in type.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IPropertyDefinition baseProperty in baseClass.GetMembersNamed(property.Name, false).OfType<IPropertyDefinition>())
{
if (baseProperty.Visibility == TypeMemberVisibility.Private) continue;
if (IsAssembly(baseProperty) && !InSameUnit(baseProperty, property))
continue;
if (filter != null && !filter.Include(baseProperty))
continue;
if (SignaturesParametersAreEqual(property, baseProperty))
return baseProperty;
}
}
return Dummy.Property;
}
public static IMethodDefinition GetHiddenBaseMethod(this IMethodDefinition method, ICciFilter filter = null)
{
if (method.IsConstructor) return Dummy.Method;
if (method.IsVirtual && !method.IsNewSlot) return Dummy.Method; // an override
ITypeDefinition type = method.ContainingTypeDefinition;
foreach (ITypeReference baseClassRef in type.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IMethodDefinition baseMethod in baseClass.GetMembersNamed(method.Name, false).OfType<IMethodDefinition>())
{
if (baseMethod.Visibility == TypeMemberVisibility.Private) continue;
if (IsAssembly(baseMethod) && !InSameUnit(baseMethod, method))
continue;
if (filter != null && !filter.Include(baseMethod))
continue;
// NOTE: Do not check method.IsHiddenBySignature here. C# is *always* hide-by-signature regardless of the metadata flag.
// Do not check return type here, C# hides based on parameter types alone.
if (SignaturesParametersAreEqual(method, baseMethod))
{
if (!method.IsGeneric && !baseMethod.IsGeneric)
return baseMethod;
if (method.GenericParameterCount == baseMethod.GenericParameterCount)
return baseMethod;
}
}
}
return Dummy.Method;
}
public CSDeclarationWriter(ISyntaxWriter writer, ICciFilter filter)
: this(writer, filter, true)
{
}
public CSDeclarationWriter(ISyntaxWriter writer, ICciFilter filter, bool forCompilation, bool includePseudoCustomAttributes = false)
: this(writer, filter, forCompilation)
{
_includeFakeAttributes = includePseudoCustomAttributes;
}
public OrFilter(ICciFilter left, ICciFilter right)
{
_left = left;
_right = right;
}
public DocumentIdWriter(TextWriter writer, ICciFilter filter)
: base(filter)
{
_writer = writer;
}
public static IFieldDefinition GetHiddenBaseField(this IFieldDefinition field, ICciFilter filter = null)
{
foreach (ITypeReference baseClassRef in field.ContainingTypeDefinition.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IFieldDefinition baseField in baseClass.GetMembersNamed(field.Name, false).OfType<IFieldDefinition>())
{
if (baseField.Visibility == TypeMemberVisibility.Private) continue;
if (IsAssembly(baseField) && !InSameUnit(baseField, field))
continue;
if (filter != null && !filter.Include(baseField))
continue;
return baseField;
}
}
return Dummy.Field;
}
public TypeListWriter(ISyntaxWriter writer, ICciFilter filter)
: base(filter)
{
_syntaxWriter = writer;
_declarationWriter = new CSDeclarationWriter(_syntaxWriter, filter, false);
}
public FilteredMetadataTraverser(ICciFilter filter)
{
this._filter = filter ?? new IncludeAllFilter();
}
public MappingDifferenceFilter(Func<DifferenceType, bool> include, ICciFilter filter)
{
_include = include;
_filter = filter;
}
public NegatedFilter(ICciFilter filter)
{
_filter = filter;
}
public static IFieldDefinition GetHiddenBaseField(this IFieldDefinition field, ICciFilter filter = null)
{
foreach (ITypeReference baseClassRef in field.ContainingTypeDefinition.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IFieldDefinition baseField in baseClass.GetMembersNamed(field.Name, false).OfType <IFieldDefinition>())
{
if (baseField.Visibility == TypeMemberVisibility.Private)
{
continue;
}
if (IsAssembly(baseField) && !InSameUnit(baseField, field))
{
continue;
}
if (filter != null && !filter.Include(baseField))
{
continue;
}
return(baseField);
}
}
return(Dummy.Field);
}
public static IEventDefinition GetHiddenBaseEvent(this IEventDefinition evnt, ICciFilter filter = null)
{
IMethodDefinition eventRep = evnt.Adder.ResolvedMethod;
if (eventRep.IsVirtual && !eventRep.IsNewSlot)
{
return(Dummy.Event); // an override
}
foreach (ITypeReference baseClassRef in evnt.ContainingTypeDefinition.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IEventDefinition baseEvent in baseClass.GetMembersNamed(evnt.Name, false).OfType <IEventDefinition>())
{
if (baseEvent.Visibility == TypeMemberVisibility.Private)
{
continue;
}
if (IsAssembly(baseEvent) && !InSameUnit(baseEvent, evnt))
{
continue;
}
if (filter != null && !filter.Include(baseEvent))
{
continue;
}
return(baseEvent);
}
}
return(Dummy.Event);
}
private static IMappingDifferenceFilter GetDiffFilter(ICciFilter filter) => new MappingDifferenceFilter(GetIncludeFilter(), filter);
public static IPropertyDefinition GetHiddenBaseProperty(this IPropertyDefinition property, ICciFilter filter = null)
{
IMethodDefinition propertyRep = property.Accessors.First().ResolvedMethod;
if (propertyRep.IsVirtual && !propertyRep.IsNewSlot)
{
return(Dummy.Property); // an override
}
ITypeDefinition type = property.ContainingTypeDefinition;
foreach (ITypeReference baseClassRef in type.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IPropertyDefinition baseProperty in baseClass.GetMembersNamed(property.Name, false).OfType <IPropertyDefinition>())
{
if (baseProperty.Visibility == TypeMemberVisibility.Private)
{
continue;
}
if (IsAssembly(baseProperty) && !InSameUnit(baseProperty, property))
{
continue;
}
if (filter != null && !filter.Include(baseProperty))
{
continue;
}
if (SignaturesParametersAreEqual(property, baseProperty))
{
return(baseProperty);
}
}
}
return(Dummy.Property);
}
public FilteredMetadataTraverser(ICciFilter filter)
{
_filter = filter ?? new IncludeAllFilter();
}
public static IMethodDefinition GetHiddenBaseMethod(this IMethodDefinition method, ICciFilter filter = null)
{
if (method.IsConstructor)
{
return(Dummy.Method);
}
if (method.IsVirtual && !method.IsNewSlot)
{
return(Dummy.Method); // an override
}
ITypeDefinition type = method.ContainingTypeDefinition;
foreach (ITypeReference baseClassRef in type.GetAllBaseTypes())
{
ITypeDefinition baseClass = baseClassRef.ResolvedType;
foreach (IMethodDefinition baseMethod in baseClass.GetMembersNamed(method.Name, false).OfType <IMethodDefinition>())
{
if (baseMethod.Visibility == TypeMemberVisibility.Private)
{
continue;
}
if (IsAssembly(baseMethod) && !InSameUnit(baseMethod, method))
{
continue;
}
if (filter != null && !filter.Include(baseMethod.UnWrapMember()))
{
continue;
}
// NOTE: Do not check method.IsHiddenBySignature here. C# is *always* hide-by-signature regardless of the metadata flag.
// Do not check return type here, C# hides based on parameter types alone.
if (SignaturesParametersAreEqual(method, baseMethod))
{
if (!method.IsGeneric && !baseMethod.IsGeneric)
{
return(baseMethod);
}
if (method.GenericParameterCount == baseMethod.GenericParameterCount)
{
return(baseMethod);
}
}
}
}
return(Dummy.Method);
}
public SimpleTypeMemberTraverser(ICciFilter filter)
{
_filter = filter ?? new IncludeAllFilter();
}
public TypesOnlyMappingDifferenceFilter(Func <DifferenceType, bool> include, ICciFilter filter)
: base(include, filter)
{
}
public DocumentIdWriter(TextWriter writer, ICciFilter filter, DocIdKinds kinds)
: base(filter)
{
_writer = writer;
_kinds = kinds;
}
private static IMappingDifferenceFilter GetDiffFilter(ICciFilter filter)
{
return new MappingDifferenceFilter(GetIncludeFilter(), filter);
}
