Set-Strictmode should not complain about COUNT & LENGTH properties on elements

[jpsnover]

One of the big problems we have had in the language has been not knowing whether the following expression was going to return a single element or an array:

$x = gps $name

We fixed this longstanding problem by masking over the issue allowing elements to be treated as arrays. e.g.

(gps -id 0).count
(gps -id 0).length

When you enable strictmode - it complains about these and it shouldn't.
I'm about to enable strictmode on a large collection of scripts and I'm sure that is going to find lots of these issue and modifying the code is not going to make the code any better - it will just cause a lot of work and reduce my reliability.

[jcotton42]

Bumping this because this is something I would also like to see

[mklement0]

Just to provide some additional info:

• The problem occurs with Set-StrictMode -Version 2 or higher, where attempts to access non-existing properties result in a statement-terminating error (e.g., The property 'Count' cannot be found on this object. Verify that the property exists.).

  • Basically, PowerShell unexpectedly treats properties .Count and .Length as non-existent, even though it normally adds them itself.

• Fortunately, the other feature related to unifying scalars and collections - indexing - works irrespective of what strict mode is in effect (e.g., (gps -id 0)[0]).

[nebosite]

Me too! I just added strict mode to my script to help me not call functions incorrectly and now I've lost the cool automatic Count property. Please fix this!

[agowa]

Any update on this?
Just noticed, that it also applies for explicitly defined arrays, which is quite irritating:

Set-StrictMode -Version 7
[pscustomobject[]]$a = $null # e.g. returned by something like 1..5 | Where-Object {$false}
$a.Count

It is especially cumbersome, as checking for the count of elements cannot be done in the same manner as if it was 1 or 2 elements, so an if statement would become like this:

if (-not [bool](Get-Member -InputObject $a -Name "Count" -ErrorAction SilentlyContinue)) {
  # Zero Elements
} elseif ($a.Count -eq 1) {
  # One Element
} else {
  # More than one element
}

It just throws the property not found exception, despite being an array and therefore having that attribute:

The property 'Count' cannot be found on this object. Verify that the property exists.
At line:1 char:1
+ $a.Count
+ ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [], PropertyNotFoundException
    + FullyQualifiedErrorId : PropertyNotFoundStrict

Edit:
Also these forms work:

Set-StrictMode -Version 7
$myArray = @()
$myArray.Count
$myArray2 = New-Object int[] 0
$myArray2.Count
$list = New-Object Collections.Generic.List[Int]
$list.Count

But unintuitively this one doesn't

Set-StrictMode -Version 7
$a = 1,2,3,4 | Where-Object {$_ -eq 5}
$a.Count
# And even more confusingly:
function a {
  [OutputType([Int64])]param($a)
  return $a.Where{$_ -gt 5}
}
[Int64[]]$notWorking = 1..5 | a
$notWorking.Count
[pscustomobject[]]$butWorks = 1..5 | a
$butWorks.Count

For the last two it gets even stranger:

# And the really confusing part:
PS C:\> [pscustomobject[]]

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     PSObject[]                               System.Array

PS C:\> [Int64[]]

IsPublic IsSerial Name                                     BaseType
-------- -------- ----                                     --------
True     True     Int64[]                                  System.Array

Therefore both variables should be of that type and behave as such and not the same as $null.

[mklement0]

PowerShell lets you assign $null or ([System.Management.Automation.Internal.AutomationNull]::Value, which is what commands that produce no output technically return) to variables that are constrained to:

• a reference type, which includes arrays and collection types, in which case these values are stored as-is (e.g.,
  [int[]] $a = $null stores $null in $a)
• a value type, if these values can be converted to that type (e.g, [int] $i = $null, which stores 0 in $a)

Operating on a reference-type-constrained variable set to $null or [System.Management.Automation.Internal.AutomationNull]::Value then operates on these values, which by definition have no properties - other than the engine-intrinsic .Count (and its .Length alias).
(Yes, actual array instances have a .Count property via the ICollection interface, but no instance exists in this case).

With strict mode off or at -Version 1, $null.Count and $null.Length do work and return 0, as expected.
With -Version 2 and above, we're again seeing the problem described in the OP:

PS> Set-StrictMode -Off; [int[]] $a = $null;  $a.Count, $a.Length
0
0

PS> Set-StrictMode -Version 2; [int[]] $a = $null;  $a.Count, $a.Length
PropertyNotFoundException: The property 'Count' cannot be found on this object. Verify that the property exists.