Automatically retrieve Allowed Types for Constrained Language mode

How can I check (in full language mode) if a specific type is compliant with constrained language mode?

You can use something like the following, based on the Test-TypePermitted function defined further below:

PS> [System.IO.FileInfo], [int] | Test-TypePermitted -Mode Constrained

TypeName           Permitted Message
--------           --------- -------
System.IO.FileInfo     False Cannot create type. Only core types are supported in this language mode.
System.Int32            True 

---

Test-TypePermitted function:

Note that the function defaults to Restricted mode rather than Constrained mode, because it seems (do tell us if I'm wrong) that Constrained mode relates to the now-defunct Windows RT mobile variant of Windows - or is it still relevant?

Official docs re PowerShell language modes (which you also link to from the question): about_Language_Modes

function Test-TypePermitted {

  [CmdletBinding(PositionalBinding = $false)]
  param(
    [Parameter(ValueFromPipeline, Position = 0)]
    [Type[]] $Type
    ,
    [Parameter(Position = 1)]
    [Alias('Mode')]
    [ValidateSet('Restricted', 'Constrained', 'FullLanguage')]
    $LanguageMode = 'Restricted'
  )

  begin {
    try {
      $ps = [powershell]::Create()
      $ps.Runspace.SessionStateProxy.LanguageMode = $LanguageMode
    } catch { Throw }
  }

  process {
    foreach ($t in $type) {

      $expression = switch -Wildcard ($LanguageMode) {
        'Restricted*' {
          # In 'RestrictedLanguage' mode, seemingly just referencing the *type*
          # of a non-permitted type causes an error.
          '[{0}]' -f $t.FullName
        }
        Default {
          # In 'ConstrainedLanguage' mode, whether a type is permitted or not
          # only surfaces when you try to *construct an instance*.
          # Note: New-Object can construct value types even without argument.
          #       For reference types, it succeeds only if there is a (public)
          #       parameterless constructor.
          #       However, fortunately, construction isn't even attempted if
          #       the type isn't permitted.
          'New-Object ''{0}''' -f $t.FullName
        }
      }

      $message = $null
      $permitted = try {
        if ($ps.AddScript($expression).Invoke().Count -ne 0) {
          $true
        } elseif ($ps.Streams.Error[0].FullyQualifiedErrorId -Match 'CannotFindAppropriateCtor') {
          # Type is permitted in principle, but couldn't be constructed due to not having a parameterless constructor.
          $true
        } else {
          # Type is not permitted.
          $message = $ps.Streams.Error[0].ToString()
          $false
        }
      } catch { # Happens in RestrictedLanguage mode.
        # Type is not permitted.
        $message = ($_.ToString() -split 'r?n')[-1].TrimEnd('"')
        $false
      }
    }

    [pscustomobject] @{
      TypeName = $t.FullName
      Permitted = $permitted
      Message = $message
    }

    # Prepare for next iteration.
    $ps.Commands.Clear(); $ps.Streams.ClearStreams()
  }

  end {
    $ps.Dispose()
  }

}