public class FSharpUnionTagsClass()

in ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Impl/DeclaredElement/CompilerGenerated/FSharpUnionTagsClass.cs [15:106]
67 lines of code
7 McCabe index (conditional complexity)

  public class FSharpUnionTagsClass([CanBeNull] TypeElement typeElement) : FSharpGeneratedMemberBase, IClass
  {
    private const string TagsClassName = "Tags";

    public readonly TypeElement Union = typeElement;

    public override DeclaredElementType GetElementType() =>
      CLRDeclaredElementType.CLASS;

    internal IUnionPart UnionPart =>
      (IUnionPart) Union.EnumerateParts().FirstOrDefault(p => p is IUnionPart);

    protected override IClrDeclaredElement ContainingElement => Union;
    public override ITypeElement GetContainingType() => Union;
    public override ITypeMember GetContainingTypeMember() => Union;

    public override string ShortName => TagsClassName;
    public IList<ITypeParameter> TypeParameters => EmptyList<ITypeParameter>.Instance;
    public int TypeParametersCount => 0;

    public IClrTypeName GetClrName() =>
      new ClrTypeName($"{Union.GetClrName().FullName}+{TagsClassName}");

    public IEnumerable<ITypeMember> GetMembers() => Constants;

    public IEnumerable<string> MemberNames =>
      UnionPart.CaseDeclarations.Select(c => c.CompiledName);

    public INamespace GetContainingNamespace() =>
      Union.GetContainingNamespace();

    public bool HasMemberWithName(string shortName, bool ignoreCase)
    {
      var comparisonRule = ignoreCase ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal;

      foreach (var name in MemberNames)
        if (string.Equals(name, shortName, comparisonRule))
          return true;

      return false;
    }

    public IPsiSourceFile GetSingleOrDefaultSourceFile() =>
      Union.GetSingleOrDefaultSourceFile();

    public override bool IsStatic => true;

    public IEnumerable<IField> Constants
    {
      get
      {
        var tags = new List<IField>();
        foreach (var unionCase in UnionPart.Cases)
          tags.Add(new FSharpUnionCaseTag(unionCase));

        return tags;
      }
    }

    public IDeclaredType GetBaseClassType() => PredefinedType.Object;
    public IClass GetSuperClass() => GetBaseClassType().GetClassType();

    public IList<IDeclaredType> GetSuperTypes() => new[] {GetBaseClassType()};
    public IList<ITypeElement> GetSuperTypeElements() => GetSuperTypes().ToTypeElements();

    public MemberPresenceFlag GetMemberPresenceFlag() =>
      MemberPresenceFlag.NONE;

    public IEnumerable<IField> Fields => EmptyList<IField>.Instance;
    public IList<ITypeElement> NestedTypes => EmptyList<ITypeElement>.Instance;
    public IEnumerable<IConstructor> Constructors => EmptyList<IConstructor>.Instance;
    public IEnumerable<IOperator> Operators => EmptyList<IOperator>.Instance;
    public IEnumerable<IMethod> Methods => EmptyList<IMethod>.Instance;
    public IEnumerable<IProperty> Properties => EmptyList<IProperty>.Instance;
    public IEnumerable<IEvent> Events => EmptyList<IEvent>.Instance;

    public override bool Equals(object obj)
    {
      if (ReferenceEquals(this, obj))
        return true;

      return obj is FSharpUnionTagsClass tags && Equals(GetContainingType(), tags.GetContainingType());
    }

    public override int GetHashCode() => Union.GetHashCode();

    public override string XMLDocId =>
      XMLDocUtil.GetTypeElementXmlDocId(this);

    public override AccessRights GetAccessRights() =>
      Union.GetRepresentationAccessRights();
  }