public static IType MapType()

in ReSharper.FSharp/src/FSharp/FSharp.Psi/src/Util/FcsTypeMappingUtil.cs [183:241]
45 lines of code
11 McCabe index (conditional complexity)

    public static IType MapType([NotNull] this ProvidedType providedType, IPsiModule module)
    {
      if (providedType is not IProxyProvidedType proxyProvidedType)
      {
        Assertion.Fail("ProvidedType should be IProxyProvidedType");
        return TypeFactory.CreateUnknownType(module);
      }

      if (proxyProvidedType.IsCreatedByProvider &&
          providedType.DeclaringType is ProxyProvidedTypeWithContext declaringType)
      {
        var declaringTypeIType = declaringType.MapType(module);

        if (declaringTypeIType.GetTypeElement() is { } x)
          return TypeFactory.CreateType(new FSharpGenerativeProvidedNestedClass(providedType, module, x));

        var recoveredTypeElement = module
          .GetSymbolScope(false)
          .GetTypeElementsByCLRName(declaringType.GetClrName())
          .FirstOrDefault(t => t is FSharpClassOrProvidedTypeAbbreviation { IsProvidedAndGenerated: true });

        Assertion.AssertNotNull(recoveredTypeElement,
          "SymbolScope must contain provided and generated FSharpClassOrProvidedTypeAbbreviation ");

        return TypeFactory.CreateType(
          new FSharpGenerativeProvidedNestedClass(providedType, module, recoveredTypeElement));
      }

      if (providedType.IsArray)
        return TypeFactory.CreateArrayType(providedType.GetElementType().MapType(module), providedType.GetArrayRank(),
          NullableAnnotation.Unknown);

      if (providedType.IsPointer)
        return TypeFactory.CreatePointerType(providedType.GetElementType().MapType(module));

      if (!providedType.IsGenericType)
        return TypeFactory.CreateTypeByCLRName(proxyProvidedType.GetClrName(), module, true);

      if (providedType.GetGenericTypeDefinition() is not IProxyProvidedType genericTypeDefinition)
      {
        Assertion.Fail("providedType.GetGenericTypeDefinition() should be IProxyProvidedType");
        return TypeFactory.CreateUnknownType(module);
      }

      var typeDefinition =
        TypeFactory.CreateTypeByCLRName(genericTypeDefinition.GetClrName(), module, true);

      var genericProvidedArgs = providedType.GetGenericArguments();
      var genericTypes = new IType[genericProvidedArgs.Length];

      for (var i = 0; i < genericProvidedArgs.Length; i++)
        genericTypes[i] = MapType(genericProvidedArgs[i], module);

      var typeElement = typeDefinition.GetTypeElement();

      return typeElement != null
        ? TypeFactory.CreateType(typeElement, genericTypes)
        : TypeFactory.CreateUnknownType(module);
    }