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); }