PowerShell · iSazonov · Jan 21, 2023 · Jan 19, 2023 · Jan 19, 2023 · Jan 21, 2023
@@ -1149,7 +1149,7 @@ private Expression UpdatePosition(Ast ast)
 
         internal ParameterExpression NewTemp(Type type, string name)
         {
-            return Expression.Variable(type, string.Format(CultureInfo.InvariantCulture, "{0}{1}", name, _tempCounter++));
+            return Expression.Variable(type, string.Create(CultureInfo.InvariantCulture, $"{name}{_tempCounter++}"));
         }
 
         internal static Type GetTypeConstraintForMethodResolution(ExpressionAst expr)

@@ -985,7 +985,7 @@ protected override Expression VisitBlock(BlockExpression node) {
             // Display <type> if the type of the BlockExpression is different from the
             // last expression's type in the block.
             if (node.Type != node.Expressions[node.Expressions.Count - 1].Type) {
-                Out(string.Format(CultureInfo.CurrentCulture, "<{0}>", node.Type.ToString()));
+                Out(string.Create(CultureInfo.CurrentCulture, $"<{node.Type}>"));
             }
 
             VisitDeclarations(node.Variables);
@@ -1124,7 +1124,7 @@ protected override Expression VisitIndex(IndexExpression node) {
         }
 
         protected override Expression VisitExtension(Expression node) {
-            Out(string.Format(CultureInfo.CurrentCulture, ".Extension<{0}>", node.GetType().ToString()));
+            Out(string.Create(CultureInfo.CurrentCulture, $".Extension<{node.GetType()}>"));
 
             if (node.CanReduce) {
                 Out(Flow.Space, "{", Flow.NewLine);
@@ -1151,25 +1151,21 @@ protected override Expression VisitDebugInfo(DebugInfoExpression node) {
         }
 
         private void DumpLabel(LabelTarget target) {
-            Out(string.Format(CultureInfo.CurrentCulture, ".LabelTarget {0}:", GetLabelTargetName(target)));
+            Out(string.Create(CultureInfo.CurrentCulture, $".LabelTarget {GetLabelTargetName(target)}:"));
         }
 
         private string GetLabelTargetName(LabelTarget target) {
             if (string.IsNullOrEmpty(target.Name)) {
                 // Create the label target name as #Label1, #Label2, etc.
-                return string.Format(CultureInfo.CurrentCulture, "#Label{0}", GetLabelTargetId(target));
+                return string.Create(CultureInfo.CurrentCulture, $"#Label{GetLabelTargetId(target)}");
             } else {
                 return GetDisplayName(target.Name);
             }
         }
 
         private void WriteLambda(LambdaExpression lambda) {
             Out(
-                string.Format(
-                    CultureInfo.CurrentCulture,
-                    ".Lambda {0}<{1}>",
-                    GetLambdaName(lambda),
-                    lambda.Type.ToString())
+                string.Create(CultureInfo.CurrentCulture, $".Lambda {GetLambdaName(lambda)}<{lambda.Type}>")
             );
 
             VisitDeclarations(lambda.Parameters);
@@ -1205,7 +1201,7 @@ private static bool ContainsWhiteSpace(string name) {
         }
 
         private static string QuoteName(string name) {
-            return string.Format(CultureInfo.CurrentCulture, "'{0}'", name);
+            return string.Create(CultureInfo.CurrentCulture, $"'{name}'");
         }
 
         private static string GetDisplayName(string name) {

@@ -296,7 +296,7 @@ public DefineTypeHelper(Parser parser, ModuleBuilder module, TypeDefinitionAst t
                 var baseClass = this.GetBaseTypes(parser, typeDefinitionAst, out interfaces);
 
                 _typeBuilder = module.DefineType(typeName, Reflection.TypeAttributes.Class | Reflection.TypeAttributes.Public, baseClass, interfaces.ToArray());
-                _staticHelpersTypeBuilder = module.DefineType(string.Format(CultureInfo.InvariantCulture, "{0}_<staticHelpers>", typeName), Reflection.TypeAttributes.Class);
+                _staticHelpersTypeBuilder = module.DefineType(string.Create(CultureInfo.InvariantCulture, $"{typeName}_<staticHelpers>"), Reflection.TypeAttributes.Class);
                 DefineCustomAttributes(_typeBuilder, typeDefinitionAst.Attributes, _parser, AttributeTargets.Class);
                 _typeDefinitionAst.Type = _typeBuilder;
 
@@ -629,7 +629,7 @@ private PropertyBuilder EmitPropertyIl(PropertyMemberAst propertyMemberAst, Type
                     getSetAttributes |= Reflection.MethodAttributes.Static;
                 }
                 // C# naming convention for backing fields.
-                string backingFieldName = string.Format(CultureInfo.InvariantCulture, "<{0}>k__BackingField", propertyMemberAst.Name);
+                string backingFieldName = string.Create(CultureInfo.InvariantCulture, $"<{propertyMemberAst.Name}>k__BackingField");
                 var backingField = _typeBuilder.DefineField(backingFieldName, type, backingFieldAttributes);
 
                 bool hasValidateAttributes = false;
@@ -937,7 +937,7 @@ private void DefineMethodBody(
                 Type returnType,
                 Action<int, string> parameterNameSetter)
             {
-                var wrapperFieldName = string.Format(CultureInfo.InvariantCulture, "<{0}>", metadataToken);
+                var wrapperFieldName = string.Create(CultureInfo.InvariantCulture, $"<{metadataToken}>");
                 var scriptBlockWrapperField = _staticHelpersTypeBuilder.DefineField(wrapperFieldName,
                                                                        typeof(ScriptBlockMemberMethodWrapper),
                                                                        FieldAttributes.Assembly | FieldAttributes.Static);

@@ -8044,7 +8044,7 @@ private static void AssertErrorIdCorrespondsToMsgString(string errorId, string e
                 }
             }
 
-            Diagnostics.Assert(msgCorrespondsToString, string.Format("Parser error ID \"{0}\" must correspond to the error message \"{1}\"", errorId, errorMsg));
+            Diagnostics.Assert(msgCorrespondsToString, string.Create(CultureInfo.InvariantCulture, $"Parser error ID \"{errorId}\" must correspond to the error message \"{errorMsg}\""));
         }
 
         private static object[] arrayOfOneArg

@@ -766,9 +766,7 @@ public string Text
                                                              _endPosition.ColumnNumber - _startPosition.ColumnNumber);
                     }
 
-                    return string.Format(CultureInfo.InvariantCulture, "{0}...{1}",
-                                         _startPosition.Line.Substring(_startPosition.ColumnNumber),
-                                         _endPosition.Line.Substring(0, _endPosition.ColumnNumber));
+                    return string.Create(CultureInfo.InvariantCulture, $"{_startPosition.Line.AsSpan(_startPosition.ColumnNumber)}...{ _endPosition.Line.AsSpan(0, _endPosition.ColumnNumber)}");
                 }
                 else
                 {

@@ -404,7 +404,7 @@ public override AstVisitAction VisitAssignmentStatement(AssignmentStatementAst a
                                 var typeAst = _symbolTable.GetCurrentTypeDefinitionAst();
                                 Diagnostics.Assert(typeAst != null, "Method scopes can exist only inside type definitions.");
 
-                                string typeString = string.Format(CultureInfo.InvariantCulture, "[{0}]::", typeAst.Name);
+                                string typeString = string.Create(CultureInfo.InvariantCulture, $"[{typeAst.Name}]::");
                                 _parser.ReportError(variableExpressionAst.Extent,
                                     nameof(ParserStrings.MissingTypeInStaticPropertyAssignment),
                                     ParserStrings.MissingTypeInStaticPropertyAssignment,

@@ -8898,7 +8898,7 @@ internal Type GetGenericType(Type generic)
                 if (!TypeName.FullName.Contains('`'))
                 {
                     var newTypeName = new TypeName(Extent,
-                        string.Format(CultureInfo.InvariantCulture, "{0}`{1}", TypeName.FullName, GenericArguments.Count));
+                        string.Create(CultureInfo.InvariantCulture, $"{TypeName.FullName}`{GenericArguments.Count}"));
                     generic = newTypeName.GetReflectionType();
                 }
             }
@@ -8925,7 +8925,7 @@ public Type GetReflectionAttributeType()
                     if (!TypeName.FullName.Contains('`'))
                     {
                         var newTypeName = new TypeName(Extent,
-                            string.Format(CultureInfo.InvariantCulture, "{0}Attribute`{1}", TypeName.FullName, GenericArguments.Count));
+                            string.Create(CultureInfo.InvariantCulture, $"{TypeName.FullName}Attribute`{GenericArguments.Count}"));
                         generic = newTypeName.GetReflectionType();
                     }
                 }

@@ -1271,7 +1271,7 @@ public override string ToString()
 
         internal virtual string ToDebugString(int indent)
         {
-            return string.Format(CultureInfo.InvariantCulture, "{0}{1}: <{2}>", StringUtil.Padding(indent), _kind, Text);
+            return string.Create(CultureInfo.InvariantCulture, $"{StringUtil.Padding(indent)}{_kind}: <{Text}>");
         }
     }
 

@@ -2033,7 +2033,7 @@ internal static Collection<PSObject> GetRemoteCommands(Guid shellId, WSManConnec
                 powerShell.AddCommand("Get-WSManInstance");
 
                 // Add parameters to enumerate commands.
-                string filterStr = string.Format(CultureInfo.InvariantCulture, "ShellId='{0}'", shellId.ToString().ToUpperInvariant());
+                string filterStr = string.Create(CultureInfo.InvariantCulture, $"ShellId='{shellId.ToString().ToUpperInvariant()}'");
                 powerShell.AddParameter("ResourceURI", @"Shell/Command");
                 powerShell.AddParameter("Enumerate", true);
                 powerShell.AddParameter("Dialect", "Selector");

@@ -1866,12 +1866,10 @@ internal static string ConfigFragment(string key, string resourceString, string
 
             if (isExample)
             {
-                return string.Format(CultureInfo.InvariantCulture, "# {0}{1}# {2:19} = {3}{4}{5}",
-                    resourceString, nl, key, value, nl, nl);
+                return string.Format(CultureInfo.InvariantCulture, "# {0}{1}# {2:19} = {3}{4}{5}", resourceString, nl, key, value, nl, nl);
             }
-
-            return string.Format(CultureInfo.InvariantCulture, "# {0}{1}{2:19} = {3}{4}{5}",
-                resourceString, nl, key, value, nl, nl);
+
+            return string.Format(CultureInfo.InvariantCulture, "# {0}{1}{2:19} = {3}{4}{5}", resourceString, nl, key, value, nl, nl);
         }
 
         /// <summary>

@@ -2239,7 +2239,7 @@ internal int StartSSHProcess(
                         StringUtil.Format(RemotingErrorIdStrings.KeyFileNotFound, this.KeyFilePath));
                 }
 
-                startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-i ""{0}""", this.KeyFilePath));
+                startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-i ""{this.KeyFilePath}"""));
             }
 
             // pass "-l login_name" command line argument to ssh if UserName is set
@@ -2252,33 +2252,33 @@ internal int StartSSHProcess(
                     // convert DOMAIN\user to user@DOMAIN
                     var domainName = parts[0];
                     var userName = parts[1];
-                    startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-l {0}@{1}", userName, domainName));
+                    startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-l {userName}@{domainName}"));
                 }
                 else
                 {
-                    startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-l {0}", this.UserName));
+                    startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-l {this.UserName}"));
                 }
             }
 
             // pass "-p port" command line argument to ssh if Port is set
             // if Port is not set, then ssh will use Port from ssh_config if defined else 22 by default
             if (this.Port != 0)
             {
-                startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-p {0}", this.Port));
+                startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-p {this.Port}"));
             }
 
             // pass "-o option=value" command line argument to ssh if options are provided
             if (this.Options != null)
             {
                 foreach (DictionaryEntry pair in this.Options)
                 {
-                    startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-o {0}={1}", pair.Key, pair.Value));
+                    startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-o {pair.Key}={pair.Value}"));
                 }
             }
 
             // pass "-s destination command" command line arguments to ssh where command is the subsystem to invoke on the destination
             // note that ssh expects IPv6 addresses to not be enclosed in square brackets so trim them if present
-            startInfo.ArgumentList.Add(string.Format(CultureInfo.InvariantCulture, @"-s {0} {1}", this.ComputerName.TrimStart('[').TrimEnd(']'), this.Subsystem));
+            startInfo.ArgumentList.Add(string.Create(CultureInfo.InvariantCulture, $@"-s {this.ComputerName.TrimStart('[').TrimEnd(']')} {this.Subsystem}"));
 
             startInfo.WorkingDirectory = System.IO.Path.GetDirectoryName(filePath);
             startInfo.CreateNoWindow = true;

@@ -364,10 +364,7 @@ internal void ProcessRawData(byte[] data,
             {
                 // we dont support this stream..so ignore the data
                 Dbg.Assert(false,
-                    string.Format(CultureInfo.InvariantCulture, "Data should be from one of the streams : {0} or {1} or {2}",
-                    WSManNativeApi.WSMAN_STREAM_ID_STDIN,
-                    WSManNativeApi.WSMAN_STREAM_ID_STDOUT,
-                    WSManNativeApi.WSMAN_STREAM_ID_PROMPTRESPONSE));
+                    string.Create(CultureInfo.InvariantCulture, $"Data should be from one of the streams : {WSManNativeApi.WSMAN_STREAM_ID_STDIN} or {WSManNativeApi.WSMAN_STREAM_ID_STDOUT} or {WSManNativeApi.WSMAN_STREAM_ID_PROMPTRESPONSE}"));
                 s_baseTracer.WriteLine("{0} is not a valid stream", stream);
             }
             // process data

@@ -926,10 +926,7 @@ internal override void ConnectAsync()
                 {
                     // WSMan expects the data to be in XML format (which is text + xml tags)
                     // so convert byte[] into base64 encoded format
-                    string base64EncodedDataInXml = string.Format(CultureInfo.InvariantCulture, "<{0} xmlns=\"{1}\">{2}</{0}>",
-                        WSManNativeApi.PS_CONNECT_XML_TAG,
-                        WSManNativeApi.PS_XML_NAMESPACE,
-                        Convert.ToBase64String(additionalData));
+                    string base64EncodedDataInXml = string.Create(CultureInfo.InvariantCulture, $"<{WSManNativeApi.PS_CONNECT_XML_TAG} xmlns=\"{WSManNativeApi.PS_XML_NAMESPACE}\">{Convert.ToBase64String(additionalData)}</{WSManNativeApi.PS_CONNECT_XML_TAG}>");
                     _openContent = new WSManNativeApi.WSManData_ManToUn(base64EncodedDataInXml);
                 }
 
@@ -1097,10 +1094,7 @@ public override void CreateAsync()
                 {
                     // WSMan expects the data to be in XML format (which is text + xml tags)
                     // so convert byte[] into base64 encoded format
-                    string base64EncodedDataInXml = string.Format(CultureInfo.InvariantCulture, "<{0} xmlns=\"{1}\">{2}</{0}>",
-                        WSManNativeApi.PS_CREATION_XML_TAG,
-                        WSManNativeApi.PS_XML_NAMESPACE,
-                        Convert.ToBase64String(additionalData));
+                    string base64EncodedDataInXml = string.Create(CultureInfo.InvariantCulture, $"<{WSManNativeApi.PS_CREATION_XML_TAG} xmlns=\"{WSManNativeApi.PS_XML_NAMESPACE}\">{Convert.ToBase64String(additionalData)}</{WSManNativeApi.PS_CREATION_XML_TAG}>");
                     _openContent = new WSManNativeApi.WSManData_ManToUn(base64EncodedDataInXml);
                 }
             }
-Original file line number
+Diff line change
@@ Expand Up @@
                     }
                 }
-                Diagnostics.Assert(msgCorrespondsToString, string.Format("Parser error ID \"{0}\" must correspond to the error message \"{1}\"", errorId, errorMsg));
+                Diagnostics.Assert(msgCorrespondsToString, string.Create(CultureInfo.InvariantCulture, $"Parser error ID \"{errorId}\" must correspond to the error message \"{errorMsg}\""));
             }
             private static object[] arrayOfOneArg
@@ Expand Down @@