Merge upstream/main into main - resolve Strings.resx conflict

Author: genXdev

.github/CODEOWNERS

@@ -1,6 +1,6 @@
 # Default owners
-* @andyleejordan @bergmeister
+* @PowerShell/extension @bergmeister
 
 # Version bumps and documentation updates
 Directory.Build.props @sdwheeler @michaeltlombardi
-/docs/ @sdwheeler @michaeltlombardi
+/docs/ @PowerShell/extension @sdwheeler @michaeltlombardi

Directory.Packages.props

@@ -6,11 +6,11 @@
     <PackageVersion Include="Microsoft.PowerShell.5.ReferenceAssemblies" Version="1.1.0" />
     <PackageVersion Include="Microsoft.Win32.Registry" Version="5.0.0" />
     <!--  The version of Newtonsoft.Json needs to be newer than the version in the oldest supported version of PowerShell 7: https://github.com/PowerShell/PowerShell/blob/v7.2.17/src/System.Management.Automation/System.Management.Automation.csproj#L15 -->
-    <PackageVersion Include="Newtonsoft.Json" Version="13.0.3" />
+    <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
     <PackageVersion Include="Pluralize.NET" Version="1.0.2" />
     <PackageVersion Include="PowerShellStandard.Library" Version="5.1.1" />
     <!-- Please update minimumPowerShellCoreVersion in PSScriptAnalyzer.psm1 when updating below SMA version for better user-facing error message -->
-    <PackageVersion Include="System.Management.Automation" Version="7.4.7" />
+    <PackageVersion Include="System.Management.Automation" Version="7.4.13" />
     <PackageVersion Include="System.Reflection.TypeExtensions" Version="4.7.0" />
   </ItemGroup>
 </Project>

Engine/CommandInfoCache.cs

@@ -80,23 +80,43 @@ public CommandInfo GetCommandInfo(string commandName, CommandTypes? commandTypes
         /// <returns>Returns null if command does not exists</returns>
         private CommandInfo GetCommandInfoInternal(string cmdName, CommandTypes? commandType)
         {
+            string moduleName = null;
+            string actualCmdName = cmdName;
+
+            // Check if cmdName is in the format "moduleName\CmdletName" (exactly one backslash)
+            int backslashIndex = cmdName.IndexOf('\\');
+            if (
+                backslashIndex > 0 &&
+                backslashIndex == cmdName.LastIndexOf('\\') &&
+                backslashIndex != cmdName.Length - 1 &&
+                backslashIndex != 0
+            )
+            {
+                moduleName = cmdName.Substring(0, backslashIndex);
+                actualCmdName = cmdName.Substring(backslashIndex + 1);
+            }
             // 'Get-Command ?' would return % for example due to PowerShell interpreting is a single-character-wildcard search and not just the ? alias.
             // For more details see https://github.com/PowerShell/PowerShell/issues/9308
-            cmdName = WildcardPattern.Escape(cmdName);
+            actualCmdName = WildcardPattern.Escape(actualCmdName);
 
             using (var ps = System.Management.Automation.PowerShell.Create())
             {
                 ps.RunspacePool = _runspacePool;
 
                 ps.AddCommand("Get-Command")
-                    .AddParameter("Name", cmdName)
+                    .AddParameter("Name", actualCmdName)
                     .AddParameter("ErrorAction", "SilentlyContinue");
 
                 if (commandType != null)
                 {
                     ps.AddParameter("CommandType", commandType);
                 }
 
+                if (!string.IsNullOrEmpty(moduleName))
+                {
+                    ps.AddParameter("Module", moduleName);
+                }
+
                 return ps.Invoke<CommandInfo>()
                     .FirstOrDefault();
             }

Engine/Generic/RuleSuppression.cs

@@ -193,12 +193,12 @@ public RuleSuppression(AttributeAst attrAst, int start, int end)
                         }
                         else if (argumentName.Equals("rulesuppressionid", StringComparison.OrdinalIgnoreCase))
                         {
-                            if (!String.IsNullOrWhiteSpace(RuleName))
+                            if (!String.IsNullOrWhiteSpace(RuleSuppressionID))
                             {
                                 Error = String.Format(Strings.NamedAndPositionalArgumentsConflictError, name);
                             }
 
-                            RuleName = (name.Argument as StringConstantExpressionAst).Value;
+                            RuleSuppressionID = (name.Argument as StringConstantExpressionAst).Value;
                         }
                         else if (argumentName.Equals("scope", StringComparison.OrdinalIgnoreCase))
                         {
@@ -333,12 +333,12 @@ public static List<RuleSuppression> GetSuppressions(IEnumerable<AttributeAst> at
                     {
                         targetAsts = scopeAst.FindAll(ast => ast is FunctionDefinitionAst && reg.IsMatch((ast as FunctionDefinitionAst).Name), true);
                     }
-                    #if !(PSV3 || PSV4)
+#if !(PSV3 || PSV4)
                     else if (scope.Equals("class", StringComparison.OrdinalIgnoreCase))
                     {
                         targetAsts = scopeAst.FindAll(ast => ast is TypeDefinitionAst && reg.IsMatch((ast as TypeDefinitionAst).Name), true);
                     }
-                    #endif
+#endif
 
                     if (targetAsts != null)
                     {

Engine/Helper.cs

@@ -761,8 +761,15 @@ public IScriptExtent GetScriptExtentForFunctionName(FunctionDefinitionAst functi
                 token =>
                 ContainsExtent(functionDefinitionAst.Extent, token.Extent)
                 && token.Text.Equals(functionDefinitionAst.Name));
-            var funcNameToken = funcNameTokens.FirstOrDefault();
-            return funcNameToken == null ? null : funcNameToken.Extent;
+
+            // If the functions name is 'function' then the first token in the
+            // list is the function keyword itself, so we need to skip it
+            if (functionDefinitionAst.Name.Equals("function", StringComparison.OrdinalIgnoreCase))
+            {
+                var funcNameToken = funcNameTokens.Skip(1).FirstOrDefault() ?? funcNameTokens.FirstOrDefault();
+                return funcNameToken?.Extent;
+            }
+            return funcNameTokens.FirstOrDefault()?.Extent;
         }
 
         /// <summary>

Engine/PSScriptAnalyzer.psm1

@@ -9,7 +9,7 @@ $PSModuleRoot = $PSModule.ModuleBase
 
 # Import the appropriate nested binary module based on the current PowerShell version
 $binaryModuleRoot = $PSModuleRoot
-[Version] $minimumPowerShellCoreVersion = '7.4.7'
+[Version] $minimumPowerShellCoreVersion = '7.4.13'
 if ($PSVersionTable.PSVersion.Major -ge 6) {
     $binaryModuleRoot = Join-Path -Path $PSModuleRoot -ChildPath "PSv$($PSVersionTable.PSVersion.Major)"
     # Minimum PowerShell Core version given by PowerShell Core support itself and

Engine/TokenOperations.cs

@@ -245,5 +245,165 @@ public Ast GetAstPosition(Token token)
             return findAstVisitor.AstPosition;
         }
 
+        /// <summary>
+        /// Returns a list of non-overlapping ranges (startOffset,endOffset) representing the start
+        /// and end of braced member access expressions. These are member accesses where the name is
+        /// enclosed in braces. The contents of such braces are treated literally as a member name.
+        /// Altering the contents of these braces by formatting is likely to break code.
+        /// </summary>
+        public List<Tuple<int, int>> GetBracedMemberAccessRanges()
+        {
+            // A list of (startOffset, endOffset) pairs representing the start
+            // and end braces of braced member access expressions.
+            var ranges = new List<Tuple<int, int>>();
+
+            var node = tokensLL.Value.First;
+            while (node != null)
+            {
+                switch (node.Value.Kind)
+                {
+#if CORECLR
+                    // TokenKind added in PS7
+                    case TokenKind.QuestionDot:
+#endif
+                    case TokenKind.Dot:
+                        break;
+                    default:
+                        node = node.Next;
+                        continue;
+                }
+
+                // Note: We don't check if the dot is part of an existing range. When we find
+                // a valid range, we skip all tokens inside it - so we won't ever evaluate a token
+                // which already part of a previously found range.
+
+                // Backward scan:
+                // Determine if this 'dot' is part of a member access.
+                // Walk left over contiguous comment tokens that are 'touching'.
+                // After skipping comments, the preceding non-comment token must also be 'touching'
+                // and one of the expected TokenKinds.
+                var leftToken = node.Previous;
+                var rightToken = node;
+                while (leftToken != null && leftToken.Value.Kind == TokenKind.Comment)
+                {
+                    if (leftToken.Value.Extent.EndOffset != rightToken.Value.Extent.StartOffset)
+                    {
+                        leftToken = null;
+                        break;
+                    }
+                    rightToken = leftToken;
+                    leftToken = leftToken.Previous;
+                }
+                if (leftToken == null)
+                {
+                    // We ran out of tokens before finding a non-comment token to the left or there
+                    // was intervening whitespace.
+                    node = node.Next;
+                    continue;
+                }
+
+                if (leftToken.Value.Extent.EndOffset != rightToken.Value.Extent.StartOffset)
+                {
+                    // There's whitespace between the two tokens
+                    node = node.Next;
+                    continue;
+                }
+
+                // Limit to valid token kinds that can precede a 'dot' in a member access.
+                switch (leftToken.Value.Kind)
+                {
+                    // Note: TokenKind.Number isn't in the list as 5.{Prop} is a syntax error
+                    // (Unexpected token). Numbers also have no properties - only methods.
+                    case TokenKind.Variable:
+                    case TokenKind.Identifier:
+                    case TokenKind.StringLiteral:
+                    case TokenKind.StringExpandable:
+                    case TokenKind.HereStringLiteral:
+                    case TokenKind.HereStringExpandable:
+                    case TokenKind.RParen:
+                    case TokenKind.RCurly:
+                    case TokenKind.RBracket:
+                        // allowed
+                        break;
+                    default:
+                        // not allowed
+                        node = node.Next;
+                        continue;
+                }
+
+                // Forward Scan:
+                // Check that the next significant token is an LCurly
+                // Starting from the token after the 'dot', walk right skipping trivia tokens:
+                //   - Comment
+                //   - NewLine
+                //   - LineContinuation (`)
+                // These may be multi-line and need not be 'touching' the dot.
+                // The first non-trivia token encountered must be an opening curly brace (LCurly) for
+                // this dot to begin a braced member access. If it is not LCurly or we run out
+                // of tokens, this dot is ignored.
+                var scan = node.Next;
+                while (scan != null)
+                {
+                    if (
+                        scan.Value.Kind == TokenKind.Comment ||
+                        scan.Value.Kind == TokenKind.NewLine ||
+                        scan.Value.Kind == TokenKind.LineContinuation
+                    )
+                    {
+                        scan = scan.Next;
+                        continue;
+                    }
+                    break;
+                }
+
+                // If we reached the end without finding a significant token, or if the found token
+                // is not LCurly, continue.
+                if (scan == null || scan.Value.Kind != TokenKind.LCurly)
+                {
+                    node = node.Next;
+                    continue;
+                }
+
+                // We have a valid token, followed by a dot, followed by an LCurly.
+                // Find the matching RCurly and create the range.
+                var lCurlyNode = scan;
+
+                // Depth count braces to find the RCurly which closes the LCurly.
+                int depth = 0;
+                LinkedListNode<Token> rcurlyNode = null;
+                while (scan != null)
+                {
+                    if (scan.Value.Kind == TokenKind.LCurly) depth++;
+                    else if (scan.Value.Kind == TokenKind.RCurly)
+                    {
+                        depth--;
+                        if (depth == 0)
+                        {
+                            rcurlyNode = scan;
+                            break;
+                        }
+                    }
+                    scan = scan.Next;
+                }
+
+                // If we didn't find a matching RCurly, something has gone wrong.
+                // Should an unmatched pair be caught by the parser as a parse error?
+                if (rcurlyNode == null)
+                {
+                    node = node.Next;
+                    continue;
+                }
+
+                ranges.Add(new Tuple<int, int>(
+                    lCurlyNode.Value.Extent.StartOffset,
+                    rcurlyNode.Value.Extent.EndOffset
+                ));
+
+                // Skip all tokens inside the excluded range.
+                node = rcurlyNode.Next;
+            }
+
+            return ranges;
+        }
     }
 }