From dcfe894a3e2b8765ea956a9966b076dba8b5fea4 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Thu, 2 Jul 2020 13:37:33 -0700 Subject: [PATCH 01/13] Generate VB syntax in a platform-agnostic manner, so that running the generators on Linux doesn't produce newline differences. --- .../GreenNodes/GreenNodeWriter.vb | 6 +++--- .../VisualBasicSyntaxGenerator/RedNodes/RedNodeWriter.vb | 6 +++--- .../RedNodes/SyntaxFactsWriter.vb | 4 ++++ 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/GreenNodes/GreenNodeWriter.vb b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/GreenNodes/GreenNodeWriter.vb index 39ceba32daf37..4a63182bbc1c6 100644 --- a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/GreenNodes/GreenNodeWriter.vb +++ b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/GreenNodes/GreenNodeWriter.vb @@ -848,15 +848,15 @@ Friend Class GreenNodeWriter ' visit all children For i = 0 To allChildren.Count - 1 If allChildren(i).IsList Then - _writer.WriteLine(" Dim {0} = VisitList(node.{1})" + vbCrLf + + _writer.WriteLine(" Dim {0} = VisitList(node.{1})" + Environment.NewLine + " If node.{2} IsNot {0}.Node Then anyChanges = True", ChildNewVarName(allChildren(i)), ChildPropertyName(allChildren(i)), ChildVarName(allChildren(i))) ElseIf KindTypeStructure(allChildren(i).ChildKind).IsToken Then - _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + vbCrLf + + _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + Environment.NewLine + " If node.{3} IsNot {0} Then anyChanges = True", ChildNewVarName(allChildren(i)), BaseTypeReference(allChildren(i)), ChildPropertyName(allChildren(i)), ChildVarName(allChildren(i))) Else - _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + vbCrLf + + _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + Environment.NewLine + " If node.{2} IsNot {0} Then anyChanges = True", ChildNewVarName(allChildren(i)), ChildPropertyTypeRef(nodeStructure, allChildren(i)), ChildVarName(allChildren(i))) End If diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/RedNodeWriter.vb b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/RedNodeWriter.vb index b75838d5af889..7b2a94bbc7872 100644 --- a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/RedNodeWriter.vb +++ b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/RedNodeWriter.vb @@ -168,7 +168,7 @@ Friend Class RedNodeWriter _writer.Write(" Case SyntaxKind." & kind.Name) first = False Else - _writer.Write("," & vbCrLf) + _writer.Write("," & Environment.NewLine) _writer.Write(" SyntaxKind." & kind.Name) End If @@ -1170,11 +1170,11 @@ Friend Class RedNodeWriter End If ElseIf KindTypeStructure(child.ChildKind).IsToken Then - _writer.WriteLine(" Dim {0} = DirectCast(VisitToken(node.{2}).Node, {3})" + vbCrLf + + _writer.WriteLine(" Dim {0} = DirectCast(VisitToken(node.{2}).Node, {3})" + Environment.NewLine + " If node.{2}.Node IsNot {0} Then anyChanges = True", ChildNewVarName(child), BaseTypeReference(child), ChildPropertyName(child), ChildConstructorTypeRef(child)) Else - _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + vbCrLf + + _writer.WriteLine(" Dim {0} = DirectCast(Visit(node.{2}), {1})" + Environment.NewLine + " If node.{2} IsNot {0} Then anyChanges = True", ChildNewVarName(child), ChildPropertyTypeRef(nodeStructure, child), ChildPropertyName(child)) End If diff --git a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/SyntaxFactsWriter.vb b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/SyntaxFactsWriter.vb index 241187fdcb0cd..0344d9a72b153 100644 --- a/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/SyntaxFactsWriter.vb +++ b/src/Tools/Source/CompilerGeneratorTools/Source/VisualBasicSyntaxGenerator/RedNodes/SyntaxFactsWriter.vb @@ -86,6 +86,10 @@ Public Class SyntaxFactsWriter tokenText = tokenText.Replace("""", """""") End If + If tokenText IsNot Nothing AndAlso tokenText.Contains(vbCrLf) Then + tokenText = tokenText.Replace(vbCrLf, Environment.NewLine) + End If + If tokenText <> Nothing Then _writer.WriteLine(" Case SyntaxKind.{0}", kind.Name) From 2477df960ce562af393d8b34cbdeea276ed5eab1 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Thu, 2 Jul 2020 14:46:50 -0700 Subject: [PATCH 02/13] Update generated syntax to the new form. --- .../Portable/Generated/CSharp.Generated.g4 | 28 +- .../Syntax.xml.Internal.Generated.cs | 961 ++++++++++++++++-- .../Generated/Syntax.xml.Main.Generated.cs | 125 ++- .../Generated/Syntax.xml.Syntax.Generated.cs | 348 ++++++- .../CSharp/Portable/Syntax/Syntax.xml | 107 +- .../CSharp/Portable/Syntax/SyntaxKind.cs | 8 + .../CSharp/Portable/Syntax/SyntaxKindFacts.cs | 12 +- .../Generated/Syntax.Test.xml.Generated.cs | 408 +++++++- 8 files changed, 1876 insertions(+), 121 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 index b522789a8b835..ff06cdb8379df 100644 --- a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 +++ b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 @@ -348,7 +348,28 @@ array_rank_specifier ; function_pointer_type - : 'delegate' '*' syntax_token? '<' parameter (',' parameter)* '>' + : 'delegate' '*' function_pointer_calling_convention? function_pointer_parameter_list + ; + +function_pointer_calling_convention + : 'managed' function_pointer_unmanaged_calling_convention_syntax_list? + | 'unmanaged' function_pointer_unmanaged_calling_convention_syntax_list? + ; + +function_pointer_unmanaged_calling_convention_syntax_list + : '[' function_pointer_unmanaged_calling_convention (',' function_pointer_unmanaged_calling_convention)* ']' + ; + +function_pointer_unmanaged_calling_convention + : identifier_token + ; + +function_pointer_parameter_list + : '<' function_pointer_parameter (',' function_pointer_parameter)* '>' + ; + +function_pointer_parameter + : attribute_list* modifier* type ; nullable_type @@ -1263,6 +1284,11 @@ base_parameter_list | parameter_list ; +base_parameter + : function_pointer_parameter + | parameter + ; + character_literal_token : /* see lexical specification */ ; diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 05ef43a82fc30..4c7e6f75c45ac 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1053,15 +1053,13 @@ internal sealed partial class FunctionPointerTypeSyntax : TypeSyntax { internal readonly SyntaxToken delegateKeyword; internal readonly SyntaxToken asteriskToken; - internal readonly SyntaxToken? callingConvention; - internal readonly SyntaxToken lessThanToken; - internal readonly GreenNode? parameters; - internal readonly SyntaxToken greaterThanToken; + internal readonly FunctionPointerCallingConventionSyntax? callingConvention; + internal readonly FunctionPointerParameterList parameters; - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken? callingConvention, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { - this.SlotCount = 6; + this.SlotCount = 4; this.AdjustFlagsAndWidth(delegateKeyword); this.delegateKeyword = delegateKeyword; this.AdjustFlagsAndWidth(asteriskToken); @@ -1071,22 +1069,15 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(lessThanToken); - this.lessThanToken = lessThanToken; - if (parameters != null) - { - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; - } - this.AdjustFlagsAndWidth(greaterThanToken); - this.greaterThanToken = greaterThanToken; + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken? callingConvention, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, SyntaxFactoryContext context) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); - this.SlotCount = 6; + this.SlotCount = 4; this.AdjustFlagsAndWidth(delegateKeyword); this.delegateKeyword = delegateKeyword; this.AdjustFlagsAndWidth(asteriskToken); @@ -1096,21 +1087,14 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(lessThanToken); - this.lessThanToken = lessThanToken; - if (parameters != null) - { - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; - } - this.AdjustFlagsAndWidth(greaterThanToken); - this.greaterThanToken = greaterThanToken; + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken? callingConvention, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) : base(kind) { - this.SlotCount = 6; + this.SlotCount = 4; this.AdjustFlagsAndWidth(delegateKeyword); this.delegateKeyword = delegateKeyword; this.AdjustFlagsAndWidth(asteriskToken); @@ -1120,15 +1104,8 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(lessThanToken); - this.lessThanToken = lessThanToken; - if (parameters != null) - { - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; - } - this.AdjustFlagsAndWidth(greaterThanToken); - this.greaterThanToken = greaterThanToken; + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; } /// SyntaxToken representing the delegate keyword. @@ -1136,13 +1113,9 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, /// SyntaxToken representing the asterisk. public SyntaxToken AsteriskToken => this.asteriskToken; /// SyntaxToken representing the optional calling convention. - public SyntaxToken? CallingConvention => this.callingConvention; - /// SyntaxToken representing the less than token. - public SyntaxToken LessThanToken => this.lessThanToken; - /// SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. - public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList Parameters => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.parameters)); - /// SyntaxToken representing the greater than token. - public SyntaxToken GreaterThanToken => this.greaterThanToken; + public FunctionPointerCallingConventionSyntax? CallingConvention => this.callingConvention; + /// List of the parameter types and return type of the function pointer. + public FunctionPointerParameterList Parameters => this.parameters; internal override GreenNode? GetSlot(int index) => index switch @@ -1150,9 +1123,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, 0 => this.delegateKeyword, 1 => this.asteriskToken, 2 => this.callingConvention, - 3 => this.lessThanToken, - 4 => this.parameters, - 5 => this.greaterThanToken, + 3 => this.parameters, _ => null, }; @@ -1161,11 +1132,11 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken callingConvention, SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax callingConvention, FunctionPointerParameterList parameters) { - if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) + if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameters != this.Parameters) { - var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, lessThanToken, parameters, greaterThanToken); + var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameters); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1179,27 +1150,148 @@ public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.lessThanToken, this.parameters, this.greaterThanToken, diagnostics, GetAnnotations()); + => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameters, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.lessThanToken, this.parameters, this.greaterThanToken, GetDiagnostics(), annotations); + => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameters, GetDiagnostics(), annotations); internal FunctionPointerTypeSyntax(ObjectReader reader) : base(reader) { - this.SlotCount = 6; + this.SlotCount = 4; var delegateKeyword = (SyntaxToken)reader.ReadValue(); AdjustFlagsAndWidth(delegateKeyword); this.delegateKeyword = delegateKeyword; var asteriskToken = (SyntaxToken)reader.ReadValue(); AdjustFlagsAndWidth(asteriskToken); this.asteriskToken = asteriskToken; - var callingConvention = (SyntaxToken?)reader.ReadValue(); + var callingConvention = (FunctionPointerCallingConventionSyntax?)reader.ReadValue(); if (callingConvention != null) { AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } + var parameters = (FunctionPointerParameterList)reader.ReadValue(); + AdjustFlagsAndWidth(parameters); + this.parameters = parameters; + } + + internal override void WriteTo(ObjectWriter writer) + { + base.WriteTo(writer); + writer.WriteValue(this.delegateKeyword); + writer.WriteValue(this.asteriskToken); + writer.WriteValue(this.callingConvention); + writer.WriteValue(this.parameters); + } + + static FunctionPointerTypeSyntax() + { + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerTypeSyntax), r => new FunctionPointerTypeSyntax(r)); + } + } + + /// Function pointer parameter list syntax. + internal sealed partial class FunctionPointerParameterList : CSharpSyntaxNode + { + internal readonly SyntaxToken lessThanToken; + internal readonly GreenNode? parameters; + internal readonly SyntaxToken greaterThanToken; + + internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + this.SlotCount = 3; + this.AdjustFlagsAndWidth(lessThanToken); + this.lessThanToken = lessThanToken; + if (parameters != null) + { + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; + } + this.AdjustFlagsAndWidth(greaterThanToken); + this.greaterThanToken = greaterThanToken; + } + + internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, SyntaxFactoryContext context) + : base(kind) + { + this.SetFactoryContext(context); + this.SlotCount = 3; + this.AdjustFlagsAndWidth(lessThanToken); + this.lessThanToken = lessThanToken; + if (parameters != null) + { + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; + } + this.AdjustFlagsAndWidth(greaterThanToken); + this.greaterThanToken = greaterThanToken; + } + + internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken) + : base(kind) + { + this.SlotCount = 3; + this.AdjustFlagsAndWidth(lessThanToken); + this.lessThanToken = lessThanToken; + if (parameters != null) + { + this.AdjustFlagsAndWidth(parameters); + this.parameters = parameters; + } + this.AdjustFlagsAndWidth(greaterThanToken); + this.greaterThanToken = greaterThanToken; + } + + /// SyntaxToken representing the less than token. + public SyntaxToken LessThanToken => this.lessThanToken; + /// SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. + public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList Parameters => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.parameters)); + /// SyntaxToken representing the greater than token. + public SyntaxToken GreaterThanToken => this.greaterThanToken; + + internal override GreenNode? GetSlot(int index) + => index switch + { + 0 => this.lessThanToken, + 1 => this.parameters, + 2 => this.greaterThanToken, + _ => null, + }; + + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerParameterList(this, parent, position); + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); + + public FunctionPointerParameterList Update(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + { + if (lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) + { + var newNode = SyntaxFactory.FunctionPointerParameterList(lessThanToken, parameters, greaterThanToken); + var diags = GetDiagnostics(); + if (diags?.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations?.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) + => new FunctionPointerParameterList(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, diagnostics, GetAnnotations()); + + internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) + => new FunctionPointerParameterList(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, GetDiagnostics(), annotations); + + internal FunctionPointerParameterList(ObjectReader reader) + : base(reader) + { + this.SlotCount = 3; var lessThanToken = (SyntaxToken)reader.ReadValue(); AdjustFlagsAndWidth(lessThanToken); this.lessThanToken = lessThanToken; @@ -1217,17 +1309,343 @@ internal FunctionPointerTypeSyntax(ObjectReader reader) internal override void WriteTo(ObjectWriter writer) { base.WriteTo(writer); - writer.WriteValue(this.delegateKeyword); - writer.WriteValue(this.asteriskToken); - writer.WriteValue(this.callingConvention); writer.WriteValue(this.lessThanToken); writer.WriteValue(this.parameters); writer.WriteValue(this.greaterThanToken); } - static FunctionPointerTypeSyntax() + static FunctionPointerParameterList() { - ObjectBinder.RegisterTypeReader(typeof(FunctionPointerTypeSyntax), r => new FunctionPointerTypeSyntax(r)); + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerParameterList), r => new FunctionPointerParameterList(r)); + } + } + + /// Function pointer calling convention syntax. + internal sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode + { + internal readonly SyntaxToken managedSpecifier; + internal readonly FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers; + + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + this.SlotCount = 2; + this.AdjustFlagsAndWidth(managedSpecifier); + this.managedSpecifier = managedSpecifier; + if (unmanagedCallingConventionSpecifiers != null) + { + this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); + this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + } + } + + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers, SyntaxFactoryContext context) + : base(kind) + { + this.SetFactoryContext(context); + this.SlotCount = 2; + this.AdjustFlagsAndWidth(managedSpecifier); + this.managedSpecifier = managedSpecifier; + if (unmanagedCallingConventionSpecifiers != null) + { + this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); + this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + } + } + + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + : base(kind) + { + this.SlotCount = 2; + this.AdjustFlagsAndWidth(managedSpecifier); + this.managedSpecifier = managedSpecifier; + if (unmanagedCallingConventionSpecifiers != null) + { + this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); + this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + } + } + + /// SyntaxToken representing whether the calling convention is managed or unmanaged. + public SyntaxToken ManagedSpecifier => this.managedSpecifier; + /// Optional list of identifiers that will contribute to an unmanaged calling convention. + public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionSpecifiers => this.unmanagedCallingConventionSpecifiers; + + internal override GreenNode? GetSlot(int index) + => index switch + { + 0 => this.managedSpecifier, + 1 => this.unmanagedCallingConventionSpecifiers, + _ => null, + }; + + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerCallingConventionSyntax(this, parent, position); + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); + + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionSpecifiers) + { + if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionSpecifiers != this.UnmanagedCallingConventionSpecifiers) + { + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionSpecifiers); + var diags = GetDiagnostics(); + if (diags?.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations?.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionSpecifiers, diagnostics, GetAnnotations()); + + internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionSpecifiers, GetDiagnostics(), annotations); + + internal FunctionPointerCallingConventionSyntax(ObjectReader reader) + : base(reader) + { + this.SlotCount = 2; + var managedSpecifier = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(managedSpecifier); + this.managedSpecifier = managedSpecifier; + var unmanagedCallingConventionSpecifiers = (FunctionPointerUnmanagedCallingConventionSyntaxList?)reader.ReadValue(); + if (unmanagedCallingConventionSpecifiers != null) + { + AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); + this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + } + } + + internal override void WriteTo(ObjectWriter writer) + { + base.WriteTo(writer); + writer.WriteValue(this.managedSpecifier); + writer.WriteValue(this.unmanagedCallingConventionSpecifiers); + } + + static FunctionPointerCallingConventionSyntax() + { + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerCallingConventionSyntax), r => new FunctionPointerCallingConventionSyntax(r)); + } + } + + /// Function pointer calling convention syntax. + internal sealed partial class FunctionPointerUnmanagedCallingConventionSyntaxList : CSharpSyntaxNode + { + internal readonly SyntaxToken openBracketToken; + internal readonly GreenNode? callingConventions; + internal readonly SyntaxToken closeBracketToken; + + internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + this.SlotCount = 3; + this.AdjustFlagsAndWidth(openBracketToken); + this.openBracketToken = openBracketToken; + if (callingConventions != null) + { + this.AdjustFlagsAndWidth(callingConventions); + this.callingConventions = callingConventions; + } + this.AdjustFlagsAndWidth(closeBracketToken); + this.closeBracketToken = closeBracketToken; + } + + internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, SyntaxFactoryContext context) + : base(kind) + { + this.SetFactoryContext(context); + this.SlotCount = 3; + this.AdjustFlagsAndWidth(openBracketToken); + this.openBracketToken = openBracketToken; + if (callingConventions != null) + { + this.AdjustFlagsAndWidth(callingConventions); + this.callingConventions = callingConventions; + } + this.AdjustFlagsAndWidth(closeBracketToken); + this.closeBracketToken = closeBracketToken; + } + + internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken) + : base(kind) + { + this.SlotCount = 3; + this.AdjustFlagsAndWidth(openBracketToken); + this.openBracketToken = openBracketToken; + if (callingConventions != null) + { + this.AdjustFlagsAndWidth(callingConventions); + this.callingConventions = callingConventions; + } + this.AdjustFlagsAndWidth(closeBracketToken); + this.closeBracketToken = closeBracketToken; + } + + /// SyntaxToken representing open bracket. + public SyntaxToken OpenBracketToken => this.openBracketToken; + /// SeparatedSyntaxList of calling convention identifiers. + public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList CallingConventions => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.callingConventions)); + /// SyntaxToken representing close bracket. + public SyntaxToken CloseBracketToken => this.closeBracketToken; + + internal override GreenNode? GetSlot(int index) + => index switch + { + 0 => this.openBracketToken, + 1 => this.callingConventions, + 2 => this.closeBracketToken, + _ => null, + }; + + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList(this, parent, position); + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + + public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + { + if (openBracketToken != this.OpenBracketToken || callingConventions != this.CallingConventions || closeBracketToken != this.CloseBracketToken) + { + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracketToken, callingConventions, closeBracketToken); + var diags = GetDiagnostics(); + if (diags?.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations?.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) + => new FunctionPointerUnmanagedCallingConventionSyntaxList(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, diagnostics, GetAnnotations()); + + internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) + => new FunctionPointerUnmanagedCallingConventionSyntaxList(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, GetDiagnostics(), annotations); + + internal FunctionPointerUnmanagedCallingConventionSyntaxList(ObjectReader reader) + : base(reader) + { + this.SlotCount = 3; + var openBracketToken = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(openBracketToken); + this.openBracketToken = openBracketToken; + var callingConventions = (GreenNode?)reader.ReadValue(); + if (callingConventions != null) + { + AdjustFlagsAndWidth(callingConventions); + this.callingConventions = callingConventions; + } + var closeBracketToken = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(closeBracketToken); + this.closeBracketToken = closeBracketToken; + } + + internal override void WriteTo(ObjectWriter writer) + { + base.WriteTo(writer); + writer.WriteValue(this.openBracketToken); + writer.WriteValue(this.callingConventions); + writer.WriteValue(this.closeBracketToken); + } + + static FunctionPointerUnmanagedCallingConventionSyntaxList() + { + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerUnmanagedCallingConventionSyntaxList), r => new FunctionPointerUnmanagedCallingConventionSyntaxList(r)); + } + } + + /// Individual function pointer unmanaged calling convention. + internal sealed partial class FunctionPointerUnmanagedCallingConventionSyntax : CSharpSyntaxNode + { + internal readonly SyntaxToken callingConvention; + + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + this.SlotCount = 1; + this.AdjustFlagsAndWidth(callingConvention); + this.callingConvention = callingConvention; + } + + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention, SyntaxFactoryContext context) + : base(kind) + { + this.SetFactoryContext(context); + this.SlotCount = 1; + this.AdjustFlagsAndWidth(callingConvention); + this.callingConvention = callingConvention; + } + + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention) + : base(kind) + { + this.SlotCount = 1; + this.AdjustFlagsAndWidth(callingConvention); + this.callingConvention = callingConvention; + } + + /// SyntaxToken the calling convention identifier. + public SyntaxToken CallingConvention => this.callingConvention; + + internal override GreenNode? GetSlot(int index) + => index == 0 ? this.callingConvention : null; + + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax(this, parent, position); + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); + + public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callingConvention) + { + if (callingConvention != this.CallingConvention) + { + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(callingConvention); + var diags = GetDiagnostics(); + if (diags?.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations?.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) + => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.callingConvention, diagnostics, GetAnnotations()); + + internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) + => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.callingConvention, GetDiagnostics(), annotations); + + internal FunctionPointerUnmanagedCallingConventionSyntax(ObjectReader reader) + : base(reader) + { + this.SlotCount = 1; + var callingConvention = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(callingConvention); + this.callingConvention = callingConvention; + } + + internal override void WriteTo(ObjectWriter writer) + { + base.WriteTo(writer); + writer.WriteValue(this.callingConvention); + } + + static FunctionPointerUnmanagedCallingConventionSyntax() + { + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerUnmanagedCallingConventionSyntax), r => new FunctionPointerUnmanagedCallingConventionSyntax(r)); } } @@ -26370,8 +26788,35 @@ static BracketedParameterListSyntax() } } + /// Base parameter syntax. + internal abstract partial class BaseParameterSyntax : CSharpSyntaxNode + { + internal BaseParameterSyntax(SyntaxKind kind, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + } + + internal BaseParameterSyntax(SyntaxKind kind) + : base(kind) + { + } + + protected BaseParameterSyntax(ObjectReader reader) + : base(reader) + { + } + + /// Gets the attribute declaration list. + public abstract Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList AttributeLists { get; } + + /// Gets the modifier list. + public abstract Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList Modifiers { get; } + + public abstract TypeSyntax? Type { get; } + } + /// Parameter syntax. - internal sealed partial class ParameterSyntax : CSharpSyntaxNode + internal sealed partial class ParameterSyntax : BaseParameterSyntax { internal readonly GreenNode? attributeLists; internal readonly GreenNode? modifiers; @@ -26465,10 +26910,10 @@ internal ParameterSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? } /// Gets the attribute declaration list. - public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList AttributeLists => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.attributeLists); + public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList AttributeLists => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.attributeLists); /// Gets the modifier list. - public Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.modifiers); - public TypeSyntax? Type => this.type; + public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.modifiers); + public override TypeSyntax? Type => this.type; /// Gets the identifier. public SyntaxToken Identifier => this.identifier; public EqualsValueClauseSyntax? Default => this.@default; @@ -26561,6 +27006,146 @@ static ParameterSyntax() } } + /// Parameter syntax. + internal sealed partial class FunctionPointerParameterSyntax : BaseParameterSyntax + { + internal readonly GreenNode? attributeLists; + internal readonly GreenNode? modifiers; + internal readonly TypeSyntax type; + + internal FunctionPointerParameterSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax type, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + : base(kind, diagnostics, annotations) + { + this.SlotCount = 3; + if (attributeLists != null) + { + this.AdjustFlagsAndWidth(attributeLists); + this.attributeLists = attributeLists; + } + if (modifiers != null) + { + this.AdjustFlagsAndWidth(modifiers); + this.modifiers = modifiers; + } + this.AdjustFlagsAndWidth(type); + this.type = type; + } + + internal FunctionPointerParameterSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax type, SyntaxFactoryContext context) + : base(kind) + { + this.SetFactoryContext(context); + this.SlotCount = 3; + if (attributeLists != null) + { + this.AdjustFlagsAndWidth(attributeLists); + this.attributeLists = attributeLists; + } + if (modifiers != null) + { + this.AdjustFlagsAndWidth(modifiers); + this.modifiers = modifiers; + } + this.AdjustFlagsAndWidth(type); + this.type = type; + } + + internal FunctionPointerParameterSyntax(SyntaxKind kind, GreenNode? attributeLists, GreenNode? modifiers, TypeSyntax type) + : base(kind) + { + this.SlotCount = 3; + if (attributeLists != null) + { + this.AdjustFlagsAndWidth(attributeLists); + this.attributeLists = attributeLists; + } + if (modifiers != null) + { + this.AdjustFlagsAndWidth(modifiers); + this.modifiers = modifiers; + } + this.AdjustFlagsAndWidth(type); + this.type = type; + } + + /// Gets the attribute declaration list. + public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList AttributeLists => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.attributeLists); + /// Gets the modifier list. + public override Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList Modifiers => new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(this.modifiers); + public override TypeSyntax Type => this.type; + + internal override GreenNode? GetSlot(int index) + => index switch + { + 0 => this.attributeLists, + 1 => this.modifiers, + 2 => this.type, + _ => null, + }; + + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerParameterSyntax(this, parent, position); + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameter(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameter(this); + + public FunctionPointerParameterSyntax Update(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList modifiers, TypeSyntax type) + { + if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || type != this.Type) + { + var newNode = SyntaxFactory.FunctionPointerParameter(attributeLists, modifiers, type); + var diags = GetDiagnostics(); + if (diags?.Length > 0) + newNode = newNode.WithDiagnosticsGreen(diags); + var annotations = GetAnnotations(); + if (annotations?.Length > 0) + newNode = newNode.WithAnnotationsGreen(annotations); + return newNode; + } + + return this; + } + + internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) + => new FunctionPointerParameterSyntax(this.Kind, this.attributeLists, this.modifiers, this.type, diagnostics, GetAnnotations()); + + internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) + => new FunctionPointerParameterSyntax(this.Kind, this.attributeLists, this.modifiers, this.type, GetDiagnostics(), annotations); + + internal FunctionPointerParameterSyntax(ObjectReader reader) + : base(reader) + { + this.SlotCount = 3; + var attributeLists = (GreenNode?)reader.ReadValue(); + if (attributeLists != null) + { + AdjustFlagsAndWidth(attributeLists); + this.attributeLists = attributeLists; + } + var modifiers = (GreenNode?)reader.ReadValue(); + if (modifiers != null) + { + AdjustFlagsAndWidth(modifiers); + this.modifiers = modifiers; + } + var type = (TypeSyntax)reader.ReadValue(); + AdjustFlagsAndWidth(type); + this.type = type; + } + + internal override void WriteTo(ObjectWriter writer) + { + base.WriteTo(writer); + writer.WriteValue(this.attributeLists); + writer.WriteValue(this.modifiers); + writer.WriteValue(this.type); + } + + static FunctionPointerParameterSyntax() + { + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerParameterSyntax), r => new FunctionPointerParameterSyntax(r)); + } + } + internal sealed partial class IncompleteMemberSyntax : MemberDeclarationSyntax { internal readonly GreenNode? attributeLists; @@ -32298,6 +32883,10 @@ internal partial class CSharpSyntaxVisitor public virtual TResult VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) => this.DefaultVisit(node); public virtual TResult VisitPointerType(PointerTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); public virtual TResult VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitTupleType(TupleTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitTupleElement(TupleElementSyntax node) => this.DefaultVisit(node); @@ -32470,6 +33059,7 @@ internal partial class CSharpSyntaxVisitor public virtual TResult VisitParameterList(ParameterListSyntax node) => this.DefaultVisit(node); public virtual TResult VisitBracketedParameterList(BracketedParameterListSyntax node) => this.DefaultVisit(node); public virtual TResult VisitParameter(ParameterSyntax node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) => this.DefaultVisit(node); public virtual TResult VisitIncompleteMember(IncompleteMemberSyntax node) => this.DefaultVisit(node); public virtual TResult VisitSkippedTokensTrivia(SkippedTokensTriviaSyntax node) => this.DefaultVisit(node); public virtual TResult VisitDocumentationCommentTrivia(DocumentationCommentTriviaSyntax node) => this.DefaultVisit(node); @@ -32527,6 +33117,10 @@ internal partial class CSharpSyntaxVisitor public virtual void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) => this.DefaultVisit(node); public virtual void VisitPointerType(PointerTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); public virtual void VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitTupleType(TupleTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitTupleElement(TupleElementSyntax node) => this.DefaultVisit(node); @@ -32699,6 +33293,7 @@ internal partial class CSharpSyntaxVisitor public virtual void VisitParameterList(ParameterListSyntax node) => this.DefaultVisit(node); public virtual void VisitBracketedParameterList(BracketedParameterListSyntax node) => this.DefaultVisit(node); public virtual void VisitParameter(ParameterSyntax node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) => this.DefaultVisit(node); public virtual void VisitIncompleteMember(IncompleteMemberSyntax node) => this.DefaultVisit(node); public virtual void VisitSkippedTokensTrivia(SkippedTokensTriviaSyntax node) => this.DefaultVisit(node); public virtual void VisitDocumentationCommentTrivia(DocumentationCommentTriviaSyntax node) => this.DefaultVisit(node); @@ -32774,7 +33369,19 @@ public override CSharpSyntaxNode VisitPointerType(PointerTypeSyntax node) => node.Update((TypeSyntax)Visit(node.ElementType), (SyntaxToken)Visit(node.AsteriskToken)); public override CSharpSyntaxNode VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (SyntaxToken)Visit(node.CallingConvention), (SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); + => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (FunctionPointerCallingConventionSyntax)Visit(node.CallingConvention), (FunctionPointerParameterList)Visit(node.Parameters)); + + public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPointerParameterList node) + => node.Update((SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); + + public override CSharpSyntaxNode VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) + => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList)Visit(node.UnmanagedCallingConventionSpecifiers)); + + public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) + => node.Update((SyntaxToken)Visit(node.OpenBracketToken), VisitList(node.CallingConventions), (SyntaxToken)Visit(node.CloseBracketToken)); + + public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) + => node.Update((SyntaxToken)Visit(node.CallingConvention)); public override CSharpSyntaxNode VisitNullableType(NullableTypeSyntax node) => node.Update((TypeSyntax)Visit(node.ElementType), (SyntaxToken)Visit(node.QuestionToken)); @@ -33292,6 +33899,9 @@ public override CSharpSyntaxNode VisitBracketedParameterList(BracketedParameterL public override CSharpSyntaxNode VisitParameter(ParameterSyntax node) => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.Type), (SyntaxToken)Visit(node.Identifier), (EqualsValueClauseSyntax)Visit(node.Default)); + public override CSharpSyntaxNode VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) + => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.Type)); + public override CSharpSyntaxNode VisitIncompleteMember(IncompleteMemberSyntax node) => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax)Visit(node.Type)); @@ -33642,20 +34252,106 @@ public PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken asteris return result; } - public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken? callingConvention, SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); if (delegateKeyword.Kind != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken == null) throw new ArgumentNullException(nameof(asteriskToken)); if (asteriskToken.Kind != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); + if (parameters == null) throw new ArgumentNullException(nameof(parameters)); +#endif + + return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameters, this.context); + } + + public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + { +#if DEBUG if (lessThanToken == null) throw new ArgumentNullException(nameof(lessThanToken)); if (lessThanToken.Kind != SyntaxKind.LessThanToken) throw new ArgumentException(nameof(lessThanToken)); if (greaterThanToken == null) throw new ArgumentNullException(nameof(greaterThanToken)); if (greaterThanToken.Kind != SyntaxKind.GreaterThanToken) throw new ArgumentException(nameof(greaterThanToken)); #endif - return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, lessThanToken, parameters.Node, greaterThanToken, this.context); + int hash; + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, this.context, out hash); + if (cached != null) return (FunctionPointerParameterList)cached; + + var result = new FunctionPointerParameterList(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, this.context); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + { +#if DEBUG + if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); + switch (managedSpecifier.Kind) + { + case SyntaxKind.ManagedKeyword: + case SyntaxKind.UnmanagedKeyword: break; + default: throw new ArgumentException(nameof(managedSpecifier)); + } +#endif + + int hash; + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, this.context, out hash); + if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; + + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, this.context); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + { +#if DEBUG + if (openBracketToken == null) throw new ArgumentNullException(nameof(openBracketToken)); + if (openBracketToken.Kind != SyntaxKind.OpenBracketToken) throw new ArgumentException(nameof(openBracketToken)); + if (closeBracketToken == null) throw new ArgumentNullException(nameof(closeBracketToken)); + if (closeBracketToken.Kind != SyntaxKind.CloseBracketToken) throw new ArgumentException(nameof(closeBracketToken)); +#endif + + int hash; + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, this.context, out hash); + if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntaxList)cached; + + var result = new FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, this.context); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + { +#if DEBUG + if (callingConvention == null) throw new ArgumentNullException(nameof(callingConvention)); + if (callingConvention.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); +#endif + + int hash; + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, this.context, out hash); + if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntax)cached; + + var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, this.context); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; } public NullableTypeSyntax NullableType(TypeSyntax elementType, SyntaxToken questionToken) @@ -37369,6 +38065,25 @@ public ParameterSyntax Parameter(Microsoft.CodeAnalysis.Syntax.InternalSyntax.Sy return new ParameterSyntax(SyntaxKind.Parameter, attributeLists.Node, modifiers.Node, type, identifier, @default, this.context); } + public FunctionPointerParameterSyntax FunctionPointerParameter(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList modifiers, TypeSyntax type) + { +#if DEBUG + if (type == null) throw new ArgumentNullException(nameof(type)); +#endif + + int hash; + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type, this.context, out hash); + if (cached != null) return (FunctionPointerParameterSyntax)cached; + + var result = new FunctionPointerParameterSyntax(SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type, this.context); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + public IncompleteMemberSyntax IncompleteMember(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList modifiers, TypeSyntax? type) { #if DEBUG @@ -38412,20 +39127,106 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken return result; } - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken? callingConvention, SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); if (delegateKeyword.Kind != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken == null) throw new ArgumentNullException(nameof(asteriskToken)); if (asteriskToken.Kind != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); + if (parameters == null) throw new ArgumentNullException(nameof(parameters)); +#endif + + return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameters); + } + + public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + { +#if DEBUG if (lessThanToken == null) throw new ArgumentNullException(nameof(lessThanToken)); if (lessThanToken.Kind != SyntaxKind.LessThanToken) throw new ArgumentException(nameof(lessThanToken)); if (greaterThanToken == null) throw new ArgumentNullException(nameof(greaterThanToken)); if (greaterThanToken.Kind != SyntaxKind.GreaterThanToken) throw new ArgumentException(nameof(greaterThanToken)); #endif - return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, lessThanToken, parameters.Node, greaterThanToken); + int hash; + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, out hash); + if (cached != null) return (FunctionPointerParameterList)cached; + + var result = new FunctionPointerParameterList(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + { +#if DEBUG + if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); + switch (managedSpecifier.Kind) + { + case SyntaxKind.ManagedKeyword: + case SyntaxKind.UnmanagedKeyword: break; + default: throw new ArgumentException(nameof(managedSpecifier)); + } +#endif + + int hash; + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, out hash); + if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; + + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + { +#if DEBUG + if (openBracketToken == null) throw new ArgumentNullException(nameof(openBracketToken)); + if (openBracketToken.Kind != SyntaxKind.OpenBracketToken) throw new ArgumentException(nameof(openBracketToken)); + if (closeBracketToken == null) throw new ArgumentNullException(nameof(closeBracketToken)); + if (closeBracketToken.Kind != SyntaxKind.CloseBracketToken) throw new ArgumentException(nameof(closeBracketToken)); +#endif + + int hash; + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, out hash); + if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntaxList)cached; + + var result = new FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + + public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + { +#if DEBUG + if (callingConvention == null) throw new ArgumentNullException(nameof(callingConvention)); + if (callingConvention.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); +#endif + + int hash; + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, out hash); + if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntax)cached; + + var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; } public static NullableTypeSyntax NullableType(TypeSyntax elementType, SyntaxToken questionToken) @@ -42139,6 +42940,25 @@ public static ParameterSyntax Parameter(Microsoft.CodeAnalysis.Syntax.InternalSy return new ParameterSyntax(SyntaxKind.Parameter, attributeLists.Node, modifiers.Node, type, identifier, @default); } + public static FunctionPointerParameterSyntax FunctionPointerParameter(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList modifiers, TypeSyntax type) + { +#if DEBUG + if (type == null) throw new ArgumentNullException(nameof(type)); +#endif + + int hash; + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type, out hash); + if (cached != null) return (FunctionPointerParameterSyntax)cached; + + var result = new FunctionPointerParameterSyntax(SyntaxKind.FunctionPointerParameter, attributeLists.Node, modifiers.Node, type); + if (hash >= 0) + { + SyntaxNodeCache.AddNode(result, hash); + } + + return result; + } + public static IncompleteMemberSyntax IncompleteMember(Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList attributeLists, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList modifiers, TypeSyntax? type) { #if DEBUG @@ -42979,6 +43799,10 @@ internal static IEnumerable GetNodeTypes() typeof(ArrayRankSpecifierSyntax), typeof(PointerTypeSyntax), typeof(FunctionPointerTypeSyntax), + typeof(FunctionPointerParameterList), + typeof(FunctionPointerCallingConventionSyntax), + typeof(FunctionPointerUnmanagedCallingConventionSyntaxList), + typeof(FunctionPointerUnmanagedCallingConventionSyntax), typeof(NullableTypeSyntax), typeof(TupleTypeSyntax), typeof(TupleElementSyntax), @@ -43151,6 +43975,7 @@ internal static IEnumerable GetNodeTypes() typeof(ParameterListSyntax), typeof(BracketedParameterListSyntax), typeof(ParameterSyntax), + typeof(FunctionPointerParameterSyntax), typeof(IncompleteMemberSyntax), typeof(SkippedTokensTriviaSyntax), typeof(DocumentationCommentTriviaSyntax), diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs index 2940354e56d5f..3f54eb59933b5 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs @@ -55,6 +55,22 @@ public partial class CSharpSyntaxVisitor [return: MaybeNull] public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerParameterList node. + [return: MaybeNull] + public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerCallingConventionSyntax node. + [return: MaybeNull] + public virtual TResult VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntaxList node. + [return: MaybeNull] + public virtual TResult VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntax node. + [return: MaybeNull] + public virtual TResult VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a NullableTypeSyntax node. [return: MaybeNull] public virtual TResult VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); @@ -743,6 +759,10 @@ public partial class CSharpSyntaxVisitor [return: MaybeNull] public virtual TResult VisitParameter(ParameterSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerParameterSyntax node. + [return: MaybeNull] + public virtual TResult VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a IncompleteMemberSyntax node. [return: MaybeNull] public virtual TResult VisitIncompleteMember(IncompleteMemberSyntax node) => this.DefaultVisit(node); @@ -948,6 +968,18 @@ public partial class CSharpSyntaxVisitor /// Called when the visitor visits a FunctionPointerTypeSyntax node. public virtual void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerParameterList node. + public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerCallingConventionSyntax node. + public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntaxList node. + public virtual void VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntax node. + public virtual void VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a NullableTypeSyntax node. public virtual void VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); @@ -1464,6 +1496,9 @@ public partial class CSharpSyntaxVisitor /// Called when the visitor visits a ParameterSyntax node. public virtual void VisitParameter(ParameterSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerParameterSyntax node. + public virtual void VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) => this.DefaultVisit(node); + /// Called when the visitor visits a IncompleteMemberSyntax node. public virtual void VisitIncompleteMember(IncompleteMemberSyntax node) => this.DefaultVisit(node); @@ -1624,7 +1659,19 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor => node.Update((TypeSyntax?)Visit(node.ElementType) ?? throw new ArgumentNullException("elementType"), VisitToken(node.AsteriskToken)); public override SyntaxNode? VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), VisitToken(node.CallingConvention), VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); + => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), (FunctionPointerCallingConventionSyntax?)Visit(node.CallingConvention), (FunctionPointerParameterList?)Visit(node.Parameters) ?? throw new ArgumentNullException("parameters")); + + public override SyntaxNode? VisitFunctionPointerParameterList(FunctionPointerParameterList node) + => node.Update(VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); + + public override SyntaxNode? VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) + => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList?)Visit(node.UnmanagedCallingConventionSpecifiers)); + + public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) + => node.Update(VisitToken(node.OpenBracketToken), VisitList(node.CallingConventions), VisitToken(node.CloseBracketToken)); + + public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) + => node.Update(VisitToken(node.CallingConvention)); public override SyntaxNode? VisitNullableType(NullableTypeSyntax node) => node.Update((TypeSyntax?)Visit(node.ElementType) ?? throw new ArgumentNullException("elementType"), VisitToken(node.QuestionToken)); @@ -2142,6 +2189,9 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor public override SyntaxNode? VisitParameter(ParameterSyntax node) => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.Type), VisitToken(node.Identifier), (EqualsValueClauseSyntax?)Visit(node.Default)); + public override SyntaxNode? VisitFunctionPointerParameter(FunctionPointerParameterSyntax node) + => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.Type) ?? throw new ArgumentNullException("type")); + public override SyntaxNode? VisitIncompleteMember(IncompleteMemberSyntax node) => node.Update(VisitList(node.AttributeLists), VisitList(node.Modifiers), (TypeSyntax?)Visit(node.Type)); @@ -2406,22 +2456,68 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType) => SyntaxFactory.PointerType(elementType, SyntaxFactory.Token(SyntaxKind.AsteriskToken)); /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken callingConvention, SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) { if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken.Kind() != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); - if (lessThanToken.Kind() != SyntaxKind.LessThanToken) throw new ArgumentException(nameof(lessThanToken)); - if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken) throw new ArgumentException(nameof(greaterThanToken)); - return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, (Syntax.InternalSyntax.SyntaxToken?)callingConvention.Node, (Syntax.InternalSyntax.SyntaxToken)lessThanToken.Node!, parameters.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)greaterThanToken.Node!).CreateRed(); + if (parameters == null) throw new ArgumentNullException(nameof(parameters)); + return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, callingConvention == null ? null : (Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)callingConvention.Green, (Syntax.InternalSyntax.FunctionPointerParameterList)parameters.Green).CreateRed(); } /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken callingConvention, SeparatedSyntaxList parameters) - => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + public static FunctionPointerTypeSyntax FunctionPointerType(FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameters); /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(SeparatedSyntaxList parameters = default) - => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default, SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + public static FunctionPointerTypeSyntax FunctionPointerType() + => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default, SyntaxFactory.FunctionPointerParameterList()); + + /// Creates a new FunctionPointerParameterList instance. + public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + { + if (lessThanToken.Kind() != SyntaxKind.LessThanToken) throw new ArgumentException(nameof(lessThanToken)); + if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken) throw new ArgumentException(nameof(greaterThanToken)); + return (FunctionPointerParameterList)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameterList((Syntax.InternalSyntax.SyntaxToken)lessThanToken.Node!, parameters.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)greaterThanToken.Node!).CreateRed(); + } + + /// Creates a new FunctionPointerParameterList instance. + public static FunctionPointerParameterList FunctionPointerParameterList(SeparatedSyntaxList parameters = default) + => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + + /// Creates a new FunctionPointerCallingConventionSyntax instance. + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + { + switch (managedSpecifier.Kind()) + { + case SyntaxKind.ManagedKeyword: + case SyntaxKind.UnmanagedKeyword: break; + default: throw new ArgumentException(nameof(managedSpecifier)); + } + return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionSpecifiers == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)unmanagedCallingConventionSpecifiers.Green).CreateRed(); + } + + /// Creates a new FunctionPointerCallingConventionSyntax instance. + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier) + => SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, default); + + /// Creates a new FunctionPointerUnmanagedCallingConventionSyntaxList instance. + public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + { + if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken) throw new ArgumentException(nameof(openBracketToken)); + if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken) throw new ArgumentException(nameof(closeBracketToken)); + return (FunctionPointerUnmanagedCallingConventionSyntaxList)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList((Syntax.InternalSyntax.SyntaxToken)openBracketToken.Node!, callingConventions.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)closeBracketToken.Node!).CreateRed(); + } + + /// Creates a new FunctionPointerUnmanagedCallingConventionSyntaxList instance. + public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SeparatedSyntaxList callingConventions = default) + => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + + /// Creates a new FunctionPointerUnmanagedCallingConventionSyntax instance. + public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + { + if (callingConvention.Kind() != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); + return (FunctionPointerUnmanagedCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConvention((Syntax.InternalSyntax.SyntaxToken)callingConvention.Node!).CreateRed(); + } /// Creates a new NullableTypeSyntax instance. public static NullableTypeSyntax NullableType(TypeSyntax elementType, SyntaxToken questionToken) @@ -5577,6 +5673,17 @@ public static ParameterSyntax Parameter(SyntaxList attribut public static ParameterSyntax Parameter(SyntaxToken identifier) => SyntaxFactory.Parameter(default, default(SyntaxTokenList), default, identifier, default); + /// Creates a new FunctionPointerParameterSyntax instance. + public static FunctionPointerParameterSyntax FunctionPointerParameter(SyntaxList attributeLists, SyntaxTokenList modifiers, TypeSyntax type) + { + if (type == null) throw new ArgumentNullException(nameof(type)); + return (FunctionPointerParameterSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameter(attributeLists.Node.ToGreenList(), modifiers.Node.ToGreenList(), (Syntax.InternalSyntax.TypeSyntax)type.Green).CreateRed(); + } + + /// Creates a new FunctionPointerParameterSyntax instance. + public static FunctionPointerParameterSyntax FunctionPointerParameter(TypeSyntax type) + => SyntaxFactory.FunctionPointerParameter(default, default(SyntaxTokenList), type); + /// Creates a new IncompleteMemberSyntax instance. public static IncompleteMemberSyntax IncompleteMember(SyntaxList attributeLists, SyntaxTokenList modifiers, TypeSyntax? type) { diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index 0535a9109294c..0fc07a880d816 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -467,7 +467,8 @@ public PointerTypeSyntax Update(TypeSyntax elementType, SyntaxToken asteriskToke public sealed partial class FunctionPointerTypeSyntax : TypeSyntax { - private SyntaxNode? parameters; + private FunctionPointerCallingConventionSyntax? callingConvention; + private FunctionPointerParameterList? parameters; internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) @@ -481,44 +482,189 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax public SyntaxToken AsteriskToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerTypeSyntax)this.Green).asteriskToken, GetChildPosition(1), GetChildIndex(1)); /// SyntaxToken representing the optional calling convention. - public SyntaxToken CallingConvention + public FunctionPointerCallingConventionSyntax? CallingConvention => GetRed(ref this.callingConvention, 2); + + /// List of the parameter types and return type of the function pointer. + public FunctionPointerParameterList Parameters => GetRed(ref this.parameters, 3)!; + + internal override SyntaxNode? GetNodeSlot(int index) + => index switch + { + 2 => GetRed(ref this.callingConvention, 2), + 3 => GetRed(ref this.parameters, 3)!, + _ => null, + }; + + internal override SyntaxNode? GetCachedSlot(int index) + => index switch + { + 2 => this.callingConvention, + 3 => this.parameters, + _ => null, + }; + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); + [return: MaybeNull] + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); + + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) { - get + if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameters != this.Parameters) { - var slot = ((Syntax.InternalSyntax.FunctionPointerTypeSyntax)this.Green).callingConvention; - return slot != null ? new SyntaxToken(this, slot, GetChildPosition(2), GetChildIndex(2)) : default; + var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameters); + var annotations = GetAnnotations(); + return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } + + return this; + } + + public FunctionPointerTypeSyntax WithDelegateKeyword(SyntaxToken delegateKeyword) => Update(delegateKeyword, this.AsteriskToken, this.CallingConvention, this.Parameters); + public FunctionPointerTypeSyntax WithAsteriskToken(SyntaxToken asteriskToken) => Update(this.DelegateKeyword, asteriskToken, this.CallingConvention, this.Parameters); + public FunctionPointerTypeSyntax WithCallingConvention(FunctionPointerCallingConventionSyntax? callingConvention) => Update(this.DelegateKeyword, this.AsteriskToken, callingConvention, this.Parameters); + public FunctionPointerTypeSyntax WithParameters(FunctionPointerParameterList parameters) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, parameters); + + public FunctionPointerTypeSyntax AddParametersParameters(params FunctionPointerParameterSyntax[] items) => WithParameters(this.Parameters.WithParameters(this.Parameters.Parameters.AddRange(items))); + } + + /// Function pointer parameter list syntax. + public sealed partial class FunctionPointerParameterList : CSharpSyntaxNode + { + private SyntaxNode? parameters; + + internal FunctionPointerParameterList(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { } /// SyntaxToken representing the less than token. - public SyntaxToken LessThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerTypeSyntax)this.Green).lessThanToken, GetChildPosition(3), GetChildIndex(3)); + public SyntaxToken LessThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterList)this.Green).lessThanToken, Position, 0); /// SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. - public SeparatedSyntaxList Parameters + public SeparatedSyntaxList Parameters { get { - var red = GetRed(ref this.parameters, 4); - return red != null ? new SeparatedSyntaxList(red, GetChildIndex(4)) : default; + var red = GetRed(ref this.parameters, 1); + return red != null ? new SeparatedSyntaxList(red, GetChildIndex(1)) : default; } } /// SyntaxToken representing the greater than token. - public SyntaxToken GreaterThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerTypeSyntax)this.Green).greaterThanToken, GetChildPosition(5), GetChildIndex(5)); + public SyntaxToken GreaterThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterList)this.Green).greaterThanToken, GetChildPosition(2), GetChildIndex(2)); - internal override SyntaxNode? GetNodeSlot(int index) => index == 4 ? GetRed(ref this.parameters, 4)! : null; + internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.parameters, 1)! : null; - internal override SyntaxNode? GetCachedSlot(int index) => index == 4 ? this.parameters : null; + internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.parameters : null; - public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); [return: MaybeNull] - public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); + + public FunctionPointerParameterList Update(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + { + if (lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) + { + var newNode = SyntaxFactory.FunctionPointerParameterList(lessThanToken, parameters, greaterThanToken); + var annotations = GetAnnotations(); + return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + } + + return this; + } + + public FunctionPointerParameterList WithLessThanToken(SyntaxToken lessThanToken) => Update(lessThanToken, this.Parameters, this.GreaterThanToken); + public FunctionPointerParameterList WithParameters(SeparatedSyntaxList parameters) => Update(this.LessThanToken, parameters, this.GreaterThanToken); + public FunctionPointerParameterList WithGreaterThanToken(SyntaxToken greaterThanToken) => Update(this.LessThanToken, this.Parameters, greaterThanToken); + + public FunctionPointerParameterList AddParameters(params FunctionPointerParameterSyntax[] items) => WithParameters(this.Parameters.AddRange(items)); + } + + /// Function pointer calling convention syntax. + public sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode + { + private FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers; + + internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { + } + + /// SyntaxToken representing whether the calling convention is managed or unmanaged. + public SyntaxToken ManagedSpecifier => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)this.Green).managedSpecifier, Position, 0); + + /// Optional list of identifiers that will contribute to an unmanaged calling convention. + public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionSpecifiers => GetRed(ref this.unmanagedCallingConventionSpecifiers, 1); + + internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.unmanagedCallingConventionSpecifiers, 1) : null; + + internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.unmanagedCallingConventionSpecifiers : null; + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); + [return: MaybeNull] + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); + + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + { + if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionSpecifiers != this.UnmanagedCallingConventionSpecifiers) + { + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionSpecifiers); + var annotations = GetAnnotations(); + return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + } + + return this; + } + + public FunctionPointerCallingConventionSyntax WithManagedSpecifier(SyntaxToken managedSpecifier) => Update(managedSpecifier, this.UnmanagedCallingConventionSpecifiers); + public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionSpecifiers(FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) => Update(this.ManagedSpecifier, unmanagedCallingConventionSpecifiers); + + public FunctionPointerCallingConventionSyntax AddUnmanagedCallingConventionSpecifiersCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) + { + var unmanagedCallingConventionSpecifiers = this.UnmanagedCallingConventionSpecifiers ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(); + return WithUnmanagedCallingConventionSpecifiers(unmanagedCallingConventionSpecifiers.WithCallingConventions(unmanagedCallingConventionSpecifiers.CallingConventions.AddRange(items))); + } + } + + /// Function pointer calling convention syntax. + public sealed partial class FunctionPointerUnmanagedCallingConventionSyntaxList : CSharpSyntaxNode + { + private SyntaxNode? callingConventions; + + internal FunctionPointerUnmanagedCallingConventionSyntaxList(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { + } + + /// SyntaxToken representing open bracket. + public SyntaxToken OpenBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)this.Green).openBracketToken, Position, 0); + + /// SeparatedSyntaxList of calling convention identifiers. + public SeparatedSyntaxList CallingConventions + { + get + { + var red = GetRed(ref this.callingConventions, 1); + return red != null ? new SeparatedSyntaxList(red, GetChildIndex(1)) : default; + } + } + + /// SyntaxToken representing close bracket. + public SyntaxToken CloseBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)this.Green).closeBracketToken, GetChildPosition(2), GetChildIndex(2)); + + internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.callingConventions, 1)! : null; + + internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.callingConventions : null; + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + [return: MaybeNull] + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, SyntaxToken callingConvention, SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { - if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) + if (openBracketToken != this.OpenBracketToken || callingConventions != this.CallingConventions || closeBracketToken != this.CloseBracketToken) { - var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, lessThanToken, parameters, greaterThanToken); + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracketToken, callingConventions, closeBracketToken); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -526,14 +672,45 @@ public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken return this; } - public FunctionPointerTypeSyntax WithDelegateKeyword(SyntaxToken delegateKeyword) => Update(delegateKeyword, this.AsteriskToken, this.CallingConvention, this.LessThanToken, this.Parameters, this.GreaterThanToken); - public FunctionPointerTypeSyntax WithAsteriskToken(SyntaxToken asteriskToken) => Update(this.DelegateKeyword, asteriskToken, this.CallingConvention, this.LessThanToken, this.Parameters, this.GreaterThanToken); - public FunctionPointerTypeSyntax WithCallingConvention(SyntaxToken callingConvention) => Update(this.DelegateKeyword, this.AsteriskToken, callingConvention, this.LessThanToken, this.Parameters, this.GreaterThanToken); - public FunctionPointerTypeSyntax WithLessThanToken(SyntaxToken lessThanToken) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, lessThanToken, this.Parameters, this.GreaterThanToken); - public FunctionPointerTypeSyntax WithParameters(SeparatedSyntaxList parameters) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, this.LessThanToken, parameters, this.GreaterThanToken); - public FunctionPointerTypeSyntax WithGreaterThanToken(SyntaxToken greaterThanToken) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, this.LessThanToken, this.Parameters, greaterThanToken); + public FunctionPointerUnmanagedCallingConventionSyntaxList WithOpenBracketToken(SyntaxToken openBracketToken) => Update(openBracketToken, this.CallingConventions, this.CloseBracketToken); + public FunctionPointerUnmanagedCallingConventionSyntaxList WithCallingConventions(SeparatedSyntaxList callingConventions) => Update(this.OpenBracketToken, callingConventions, this.CloseBracketToken); + public FunctionPointerUnmanagedCallingConventionSyntaxList WithCloseBracketToken(SyntaxToken closeBracketToken) => Update(this.OpenBracketToken, this.CallingConventions, closeBracketToken); - public FunctionPointerTypeSyntax AddParameters(params ParameterSyntax[] items) => WithParameters(this.Parameters.AddRange(items)); + public FunctionPointerUnmanagedCallingConventionSyntaxList AddCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) => WithCallingConventions(this.CallingConventions.AddRange(items)); + } + + /// Individual function pointer unmanaged calling convention. + public sealed partial class FunctionPointerUnmanagedCallingConventionSyntax : CSharpSyntaxNode + { + internal FunctionPointerUnmanagedCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { + } + + /// SyntaxToken the calling convention identifier. + public SyntaxToken CallingConvention => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax)this.Green).callingConvention, Position, 0); + + internal override SyntaxNode? GetNodeSlot(int index) => null; + + internal override SyntaxNode? GetCachedSlot(int index) => null; + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); + [return: MaybeNull] + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); + + public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callingConvention) + { + if (callingConvention != this.CallingConvention) + { + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(callingConvention); + var annotations = GetAnnotations(); + return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + } + + return this; + } + + public FunctionPointerUnmanagedCallingConventionSyntax WithCallingConvention(SyntaxToken callingConvention) => Update(callingConvention); } /// Class which represents the syntax node for a nullable type. @@ -11465,8 +11642,37 @@ public BracketedParameterListSyntax Update(SyntaxToken openBracketToken, Separat public new BracketedParameterListSyntax AddParameters(params ParameterSyntax[] items) => WithParameters(this.Parameters.AddRange(items)); } + /// Base parameter syntax. + public abstract partial class BaseParameterSyntax : CSharpSyntaxNode + { + internal BaseParameterSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { + } + + /// Gets the attribute declaration list. + public abstract SyntaxList AttributeLists { get; } + public BaseParameterSyntax WithAttributeLists(SyntaxList attributeLists) => WithAttributeListsCore(attributeLists); + internal abstract BaseParameterSyntax WithAttributeListsCore(SyntaxList attributeLists); + + public BaseParameterSyntax AddAttributeLists(params AttributeListSyntax[] items) => AddAttributeListsCore(items); + internal abstract BaseParameterSyntax AddAttributeListsCore(params AttributeListSyntax[] items); + + /// Gets the modifier list. + public abstract SyntaxTokenList Modifiers { get; } + public BaseParameterSyntax WithModifiers(SyntaxTokenList modifiers) => WithModifiersCore(modifiers); + internal abstract BaseParameterSyntax WithModifiersCore(SyntaxTokenList modifiers); + + public BaseParameterSyntax AddModifiers(params SyntaxToken[] items) => AddModifiersCore(items); + internal abstract BaseParameterSyntax AddModifiersCore(params SyntaxToken[] items); + + public abstract TypeSyntax? Type { get; } + public BaseParameterSyntax WithType(TypeSyntax? type) => WithTypeCore(type); + internal abstract BaseParameterSyntax WithTypeCore(TypeSyntax? type); + } + /// Parameter syntax. - public sealed partial class ParameterSyntax : CSharpSyntaxNode + public sealed partial class ParameterSyntax : BaseParameterSyntax { private SyntaxNode? attributeLists; private TypeSyntax? type; @@ -11478,10 +11684,10 @@ internal ParameterSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? pare } /// Gets the attribute declaration list. - public SyntaxList AttributeLists => new SyntaxList(GetRed(ref this.attributeLists, 0)); + public override SyntaxList AttributeLists => new SyntaxList(GetRed(ref this.attributeLists, 0)); /// Gets the modifier list. - public SyntaxTokenList Modifiers + public override SyntaxTokenList Modifiers { get { @@ -11490,7 +11696,7 @@ public SyntaxTokenList Modifiers } } - public TypeSyntax? Type => GetRed(ref this.type, 2); + public override TypeSyntax? Type => GetRed(ref this.type, 2); /// Gets the identifier. public SyntaxToken Identifier => new SyntaxToken(this, ((Syntax.InternalSyntax.ParameterSyntax)this.Green).identifier, GetChildPosition(3), GetChildIndex(3)); @@ -11531,14 +11737,90 @@ public ParameterSyntax Update(SyntaxList attributeLists, Sy return this; } - public ParameterSyntax WithAttributeLists(SyntaxList attributeLists) => Update(attributeLists, this.Modifiers, this.Type, this.Identifier, this.Default); - public ParameterSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.Type, this.Identifier, this.Default); - public ParameterSyntax WithType(TypeSyntax? type) => Update(this.AttributeLists, this.Modifiers, type, this.Identifier, this.Default); + internal override BaseParameterSyntax WithAttributeListsCore(SyntaxList attributeLists) => WithAttributeLists(attributeLists); + public new ParameterSyntax WithAttributeLists(SyntaxList attributeLists) => Update(attributeLists, this.Modifiers, this.Type, this.Identifier, this.Default); + internal override BaseParameterSyntax WithModifiersCore(SyntaxTokenList modifiers) => WithModifiers(modifiers); + public new ParameterSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.Type, this.Identifier, this.Default); + internal override BaseParameterSyntax WithTypeCore(TypeSyntax? type) => WithType(type); + public new ParameterSyntax WithType(TypeSyntax? type) => Update(this.AttributeLists, this.Modifiers, type, this.Identifier, this.Default); public ParameterSyntax WithIdentifier(SyntaxToken identifier) => Update(this.AttributeLists, this.Modifiers, this.Type, identifier, this.Default); public ParameterSyntax WithDefault(EqualsValueClauseSyntax? @default) => Update(this.AttributeLists, this.Modifiers, this.Type, this.Identifier, @default); - public ParameterSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items)); - public ParameterSyntax AddModifiers(params SyntaxToken[] items) => WithModifiers(this.Modifiers.AddRange(items)); + internal override BaseParameterSyntax AddAttributeListsCore(params AttributeListSyntax[] items) => AddAttributeLists(items); + public new ParameterSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items)); + internal override BaseParameterSyntax AddModifiersCore(params SyntaxToken[] items) => AddModifiers(items); + public new ParameterSyntax AddModifiers(params SyntaxToken[] items) => WithModifiers(this.Modifiers.AddRange(items)); + } + + /// Parameter syntax. + public sealed partial class FunctionPointerParameterSyntax : BaseParameterSyntax + { + private SyntaxNode? attributeLists; + private TypeSyntax? type; + + internal FunctionPointerParameterSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + : base(green, parent, position) + { + } + + /// Gets the attribute declaration list. + public override SyntaxList AttributeLists => new SyntaxList(GetRed(ref this.attributeLists, 0)); + + /// Gets the modifier list. + public override SyntaxTokenList Modifiers + { + get + { + var slot = this.Green.GetSlot(1); + return slot != null ? new SyntaxTokenList(this, slot, GetChildPosition(1), GetChildIndex(1)) : default; + } + } + + public override TypeSyntax Type => GetRed(ref this.type, 2)!; + + internal override SyntaxNode? GetNodeSlot(int index) + => index switch + { + 0 => GetRedAtZero(ref this.attributeLists)!, + 2 => GetRed(ref this.type, 2)!, + _ => null, + }; + + internal override SyntaxNode? GetCachedSlot(int index) + => index switch + { + 0 => this.attributeLists, + 2 => this.type, + _ => null, + }; + + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameter(this); + [return: MaybeNull] + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameter(this); + + public FunctionPointerParameterSyntax Update(SyntaxList attributeLists, SyntaxTokenList modifiers, TypeSyntax type) + { + if (attributeLists != this.AttributeLists || modifiers != this.Modifiers || type != this.Type) + { + var newNode = SyntaxFactory.FunctionPointerParameter(attributeLists, modifiers, type); + var annotations = GetAnnotations(); + return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + } + + return this; + } + + internal override BaseParameterSyntax WithAttributeListsCore(SyntaxList attributeLists) => WithAttributeLists(attributeLists); + public new FunctionPointerParameterSyntax WithAttributeLists(SyntaxList attributeLists) => Update(attributeLists, this.Modifiers, this.Type); + internal override BaseParameterSyntax WithModifiersCore(SyntaxTokenList modifiers) => WithModifiers(modifiers); + public new FunctionPointerParameterSyntax WithModifiers(SyntaxTokenList modifiers) => Update(this.AttributeLists, modifiers, this.Type); + internal override BaseParameterSyntax WithTypeCore(TypeSyntax? type) => WithType(type ?? throw new ArgumentNullException(nameof(type))); + public new FunctionPointerParameterSyntax WithType(TypeSyntax type) => Update(this.AttributeLists, this.Modifiers, type); + + internal override BaseParameterSyntax AddAttributeListsCore(params AttributeListSyntax[] items) => AddAttributeLists(items); + public new FunctionPointerParameterSyntax AddAttributeLists(params AttributeListSyntax[] items) => WithAttributeLists(this.AttributeLists.AddRange(items)); + internal override BaseParameterSyntax AddModifiersCore(params SyntaxToken[] items) => AddModifiers(items); + public new FunctionPointerParameterSyntax AddModifiers(params SyntaxToken[] items) => WithModifiers(this.Modifiers.AddRange(items)); } public sealed partial class IncompleteMemberSyntax : MemberDeclarationSyntax diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml index 1549c7356df01..b7ecd3461119d 100644 --- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml +++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml @@ -237,18 +237,29 @@ SyntaxToken representing the asterisk. - + SyntaxToken representing the optional calling convention. + + + List of the parameter types and return type of the function pointer. + + + + + + Function pointer parameter list syntax. + + SyntaxToken representing the less than token. - + SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. @@ -260,6 +271,59 @@ + + + Function pointer calling convention syntax. + + + + + + + SyntaxToken representing whether the calling convention is managed or unmanaged. + + + + + Optional list of identifiers that will contribute to an unmanaged calling convention. + + + + + + Function pointer calling convention syntax. + + + + + + SyntaxToken representing open bracket. + + + + + SeparatedSyntaxList of calling convention identifiers. + + + + + + SyntaxToken representing close bracket. + + + + + + Individual function pointer unmanaged calling convention. + + + + + + SyntaxToken the calling convention identifier. + + + @@ -4027,11 +4091,10 @@ - + - Parameter syntax. + Base parameter syntax. - Gets the attribute declaration list. @@ -4043,6 +4106,23 @@ + + + + Parameter syntax. + + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + Gets the identifier. @@ -4052,6 +4132,23 @@ + + + Parameter syntax. + + + + + Gets the attribute declaration list. + + + + + Gets the modifier list. + + + + n diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs index fde6f519abf04..6b3b9d57b7ca4 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs @@ -205,6 +205,8 @@ public enum SyntaxKind : ushort WithKeyword = 8442, InitKeyword = 8443, RecordKeyword = 8444, + ManagedKeyword = 8445, + UnmanagedKeyword = 8446, /// when adding a contextual keyword following functions must be adapted: /// @@ -615,7 +617,11 @@ public enum SyntaxKind : ushort ImplicitStackAllocArrayCreationExpression = 9053, SuppressNullableWarningExpression = 9054, NullableDirectiveTrivia = 9055, + FunctionPointerType = 9056, + FunctionPointerParameter = 9057, + FunctionPointerParameterList = 9058, + FunctionPointerCallingConventionList = 9059, InitAccessorDeclaration = 9060, @@ -624,5 +630,7 @@ public enum SyntaxKind : ushort RecordDeclaration = 9063, PrimaryConstructorBaseType = 9065, + + FunctionPointerUnmanagedCallingConventionList = 9066, } } diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs index 7ad2efa10b00c..1abd627dd13fb 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs @@ -1073,7 +1073,7 @@ public static SyntaxKind GetPreprocessorKeywordKind(string text) public static IEnumerable GetContextualKeywordKinds() { - for (int i = (int)SyntaxKind.YieldKeyword; i <= (int)SyntaxKind.InitKeyword; i++) + for (int i = (int)SyntaxKind.YieldKeyword; i <= (int)SyntaxKind.UnmanagedKeyword; i++) { yield return (SyntaxKind)i; } @@ -1125,6 +1125,8 @@ public static bool IsContextualKeyword(SyntaxKind kind) case SyntaxKind.WithKeyword: case SyntaxKind.InitKeyword: case SyntaxKind.RecordKeyword: + case SyntaxKind.ManagedKeyword: + case SyntaxKind.UnmanagedKeyword: return true; default: return false; @@ -1242,6 +1244,10 @@ public static SyntaxKind GetContextualKeywordKind(string text) return SyntaxKind.InitKeyword; case "record": return SyntaxKind.RecordKeyword; + case "managed": + return SyntaxKind.ManagedKeyword; + case "unmanaged": + return SyntaxKind.UnmanagedKeyword; default: return SyntaxKind.None; } @@ -1675,6 +1681,10 @@ public static string GetText(SyntaxKind kind) return "init"; case SyntaxKind.RecordKeyword: return "record"; + case SyntaxKind.ManagedKeyword: + return "managed"; + case SyntaxKind.UnmanagedKeyword: + return "unmanaged"; default: return string.Empty; } diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs index 1fe6a5b00fce9..e942cbbab3a92 100644 --- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs +++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs @@ -38,7 +38,19 @@ private static Syntax.InternalSyntax.PointerTypeSyntax GeneratePointerType() => InternalSyntaxFactory.PointerType(GenerateIdentifierName(), InternalSyntaxFactory.Token(SyntaxKind.AsteriskToken)); private static Syntax.InternalSyntax.FunctionPointerTypeSyntax GenerateFunctionPointerType() - => InternalSyntaxFactory.FunctionPointerType(InternalSyntaxFactory.Token(SyntaxKind.DelegateKeyword), InternalSyntaxFactory.Token(SyntaxKind.AsteriskToken), null, InternalSyntaxFactory.Token(SyntaxKind.LessThanToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + => InternalSyntaxFactory.FunctionPointerType(InternalSyntaxFactory.Token(SyntaxKind.DelegateKeyword), InternalSyntaxFactory.Token(SyntaxKind.AsteriskToken), null, GenerateFunctionPointerParameterList()); + + private static Syntax.InternalSyntax.FunctionPointerParameterList GenerateFunctionPointerParameterList() + => InternalSyntaxFactory.FunctionPointerParameterList(InternalSyntaxFactory.Token(SyntaxKind.LessThanToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + + private static Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() + => InternalSyntaxFactory.FunctionPointerCallingConvention(InternalSyntaxFactory.Token(SyntaxKind.ManagedKeyword), null); + + private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList GenerateFunctionPointerUnmanagedCallingConventionSyntaxList() + => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(InternalSyntaxFactory.Token(SyntaxKind.OpenBracketToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + + private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() + => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConvention(InternalSyntaxFactory.Identifier("CallingConvention")); private static Syntax.InternalSyntax.NullableTypeSyntax GenerateNullableType() => InternalSyntaxFactory.NullableType(GenerateIdentifierName(), InternalSyntaxFactory.Token(SyntaxKind.QuestionToken)); @@ -556,6 +568,9 @@ private static Syntax.InternalSyntax.BracketedParameterListSyntax GenerateBracke private static Syntax.InternalSyntax.ParameterSyntax GenerateParameter() => InternalSyntaxFactory.Parameter(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), null, InternalSyntaxFactory.Identifier("Identifier"), null); + private static Syntax.InternalSyntax.FunctionPointerParameterSyntax GenerateFunctionPointerParameter() + => InternalSyntaxFactory.FunctionPointerParameter(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), GenerateIdentifierName()); + private static Syntax.InternalSyntax.IncompleteMemberSyntax GenerateIncompleteMember() => InternalSyntaxFactory.IncompleteMember(new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SyntaxList(), null); @@ -796,6 +811,16 @@ public void TestFunctionPointerTypeFactoryAndProperties() Assert.Equal(SyntaxKind.DelegateKeyword, node.DelegateKeyword.Kind); Assert.Equal(SyntaxKind.AsteriskToken, node.AsteriskToken.Kind); Assert.Null(node.CallingConvention); + Assert.NotNull(node.Parameters); + + AttachAndCheckDiagnostics(node); + } + + [Fact] + public void TestFunctionPointerParameterListFactoryAndProperties() + { + var node = GenerateFunctionPointerParameterList(); + Assert.Equal(SyntaxKind.LessThanToken, node.LessThanToken.Kind); Assert.Equal(default, node.Parameters); Assert.Equal(SyntaxKind.GreaterThanToken, node.GreaterThanToken.Kind); @@ -803,6 +828,39 @@ public void TestFunctionPointerTypeFactoryAndProperties() AttachAndCheckDiagnostics(node); } + [Fact] + public void TestFunctionPointerCallingConventionFactoryAndProperties() + { + var node = GenerateFunctionPointerCallingConvention(); + + Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind); + Assert.Null(node.UnmanagedCallingConventionSpecifiers); + + AttachAndCheckDiagnostics(node); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListFactoryAndProperties() + { + var node = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + + Assert.Equal(SyntaxKind.OpenBracketToken, node.OpenBracketToken.Kind); + Assert.Equal(default, node.CallingConventions); + Assert.Equal(SyntaxKind.CloseBracketToken, node.CloseBracketToken.Kind); + + AttachAndCheckDiagnostics(node); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionFactoryAndProperties() + { + var node = GenerateFunctionPointerUnmanagedCallingConvention(); + + Assert.Equal(SyntaxKind.IdentifierToken, node.CallingConvention.Kind); + + AttachAndCheckDiagnostics(node); + } + [Fact] public void TestNullableTypeFactoryAndProperties() { @@ -3023,6 +3081,18 @@ public void TestParameterFactoryAndProperties() AttachAndCheckDiagnostics(node); } + [Fact] + public void TestFunctionPointerParameterFactoryAndProperties() + { + var node = GenerateFunctionPointerParameter(); + + Assert.Equal(default, node.AttributeLists); + Assert.Equal(default, node.Modifiers); + Assert.NotNull(node.Type); + + AttachAndCheckDiagnostics(node); + } + [Fact] public void TestIncompleteMemberFactoryAndProperties() { @@ -3839,6 +3909,110 @@ public void TestFunctionPointerTypeIdentityRewriter() Assert.Same(oldNode, newNode); } + [Fact] + public void TestFunctionPointerParameterListTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerParameterList(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerParameterListIdentityRewriter() + { + var oldNode = GenerateFunctionPointerParameterList(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerCallingConventionTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerCallingConvention(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerCallingConventionIdentityRewriter() + { + var oldNode = GenerateFunctionPointerCallingConvention(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListIdentityRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConvention(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionIdentityRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConvention(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + [Fact] public void TestNullableTypeTokenDeleteRewriter() { @@ -8311,6 +8485,32 @@ public void TestParameterIdentityRewriter() Assert.Same(oldNode, newNode); } + [Fact] + public void TestFunctionPointerParameterTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerParameter(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerParameterIdentityRewriter() + { + var oldNode = GenerateFunctionPointerParameter(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + [Fact] public void TestIncompleteMemberTokenDeleteRewriter() { @@ -9462,7 +9662,19 @@ private static PointerTypeSyntax GeneratePointerType() => SyntaxFactory.PointerType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.AsteriskToken)); private static FunctionPointerTypeSyntax GenerateFunctionPointerType() - => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(FunctionPointerCallingConventionSyntax), GenerateFunctionPointerParameterList()); + + private static FunctionPointerParameterList GenerateFunctionPointerParameterList() + => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); + + private static FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() + => SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionSyntaxList)); + + private static FunctionPointerUnmanagedCallingConventionSyntaxList GenerateFunctionPointerUnmanagedCallingConventionSyntaxList() + => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + + private static FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() + => SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("CallingConvention")); private static NullableTypeSyntax GenerateNullableType() => SyntaxFactory.NullableType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken)); @@ -9980,6 +10192,9 @@ private static BracketedParameterListSyntax GenerateBracketedParameterList() private static ParameterSyntax GenerateParameter() => SyntaxFactory.Parameter(new SyntaxList(), new SyntaxTokenList(), default(TypeSyntax), SyntaxFactory.Identifier("Identifier"), default(EqualsValueClauseSyntax)); + private static FunctionPointerParameterSyntax GenerateFunctionPointerParameter() + => SyntaxFactory.FunctionPointerParameter(new SyntaxList(), new SyntaxTokenList(), GenerateIdentifierName()); + private static IncompleteMemberSyntax GenerateIncompleteMember() => SyntaxFactory.IncompleteMember(new SyntaxList(), new SyntaxTokenList(), default(TypeSyntax)); @@ -10219,11 +10434,54 @@ public void TestFunctionPointerTypeFactoryAndProperties() Assert.Equal(SyntaxKind.DelegateKeyword, node.DelegateKeyword.Kind()); Assert.Equal(SyntaxKind.AsteriskToken, node.AsteriskToken.Kind()); - Assert.Equal(SyntaxKind.None, node.CallingConvention.Kind()); + Assert.Null(node.CallingConvention); + Assert.NotNull(node.Parameters); + var newNode = node.WithDelegateKeyword(node.DelegateKeyword).WithAsteriskToken(node.AsteriskToken).WithCallingConvention(node.CallingConvention).WithParameters(node.Parameters); + Assert.Equal(node, newNode); + } + + [Fact] + public void TestFunctionPointerParameterListFactoryAndProperties() + { + var node = GenerateFunctionPointerParameterList(); + Assert.Equal(SyntaxKind.LessThanToken, node.LessThanToken.Kind()); Assert.Equal(default, node.Parameters); Assert.Equal(SyntaxKind.GreaterThanToken, node.GreaterThanToken.Kind()); - var newNode = node.WithDelegateKeyword(node.DelegateKeyword).WithAsteriskToken(node.AsteriskToken).WithCallingConvention(node.CallingConvention).WithLessThanToken(node.LessThanToken).WithParameters(node.Parameters).WithGreaterThanToken(node.GreaterThanToken); + var newNode = node.WithLessThanToken(node.LessThanToken).WithParameters(node.Parameters).WithGreaterThanToken(node.GreaterThanToken); + Assert.Equal(node, newNode); + } + + [Fact] + public void TestFunctionPointerCallingConventionFactoryAndProperties() + { + var node = GenerateFunctionPointerCallingConvention(); + + Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind()); + Assert.Null(node.UnmanagedCallingConventionSpecifiers); + var newNode = node.WithManagedSpecifier(node.ManagedSpecifier).WithUnmanagedCallingConventionSpecifiers(node.UnmanagedCallingConventionSpecifiers); + Assert.Equal(node, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListFactoryAndProperties() + { + var node = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + + Assert.Equal(SyntaxKind.OpenBracketToken, node.OpenBracketToken.Kind()); + Assert.Equal(default, node.CallingConventions); + Assert.Equal(SyntaxKind.CloseBracketToken, node.CloseBracketToken.Kind()); + var newNode = node.WithOpenBracketToken(node.OpenBracketToken).WithCallingConventions(node.CallingConventions).WithCloseBracketToken(node.CloseBracketToken); + Assert.Equal(node, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionFactoryAndProperties() + { + var node = GenerateFunctionPointerUnmanagedCallingConvention(); + + Assert.Equal(SyntaxKind.IdentifierToken, node.CallingConvention.Kind()); + var newNode = node.WithCallingConvention(node.CallingConvention); Assert.Equal(node, newNode); } @@ -12447,6 +12705,18 @@ public void TestParameterFactoryAndProperties() Assert.Equal(node, newNode); } + [Fact] + public void TestFunctionPointerParameterFactoryAndProperties() + { + var node = GenerateFunctionPointerParameter(); + + Assert.Equal(default, node.AttributeLists); + Assert.Equal(default, node.Modifiers); + Assert.NotNull(node.Type); + var newNode = node.WithAttributeLists(node.AttributeLists).WithModifiers(node.Modifiers).WithType(node.Type); + Assert.Equal(node, newNode); + } + [Fact] public void TestIncompleteMemberFactoryAndProperties() { @@ -13263,6 +13533,110 @@ public void TestFunctionPointerTypeIdentityRewriter() Assert.Same(oldNode, newNode); } + [Fact] + public void TestFunctionPointerParameterListTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerParameterList(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerParameterListIdentityRewriter() + { + var oldNode = GenerateFunctionPointerParameterList(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerCallingConventionTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerCallingConvention(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerCallingConventionIdentityRewriter() + { + var oldNode = GenerateFunctionPointerCallingConvention(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionSyntaxListIdentityRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConvention(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerUnmanagedCallingConventionIdentityRewriter() + { + var oldNode = GenerateFunctionPointerUnmanagedCallingConvention(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + [Fact] public void TestNullableTypeTokenDeleteRewriter() { @@ -17735,6 +18109,32 @@ public void TestParameterIdentityRewriter() Assert.Same(oldNode, newNode); } + [Fact] + public void TestFunctionPointerParameterTokenDeleteRewriter() + { + var oldNode = GenerateFunctionPointerParameter(); + var rewriter = new TokenDeleteRewriter(); + var newNode = rewriter.Visit(oldNode); + + if(!oldNode.IsMissing) + { + Assert.NotEqual(oldNode, newNode); + } + + Assert.NotNull(newNode); + Assert.True(newNode.IsMissing, "No tokens => missing"); + } + + [Fact] + public void TestFunctionPointerParameterIdentityRewriter() + { + var oldNode = GenerateFunctionPointerParameter(); + var rewriter = new IdentityRewriter(); + var newNode = rewriter.Visit(oldNode); + + Assert.Same(oldNode, newNode); + } + [Fact] public void TestIncompleteMemberTokenDeleteRewriter() { From 739e2e82032977e47845f52587ef6dbb1a439abe Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Mon, 6 Jul 2020 09:54:24 -0700 Subject: [PATCH 03/13] Update parsing and binding implementation for the new syntax. --- .../CSharp/Portable/CSharpResources.resx | 3 + .../CSharp/Portable/Errors/ErrorCode.cs | 5 + .../Syntax.xml.Internal.Generated.cs | 184 +- .../Generated/Syntax.xml.Main.Generated.cs | 26 +- .../Generated/Syntax.xml.Syntax.Generated.cs | 58 +- .../CSharp/Portable/Parser/LanguageParser.cs | 216 +- .../FunctionPointerMethodSymbol.cs | 46 +- .../FunctionPointerTypeSymbol.cs | 11 - .../Symbols/Source/ParameterHelpers.cs | 41 +- .../CSharp/Portable/Syntax/Syntax.xml | 8 +- .../Portable/Syntax/SyntaxExtensions.cs | 4 +- .../CSharp/Portable/Syntax/SyntaxFacts.cs | 3 +- .../CSharp/Portable/Syntax/SyntaxKind.cs | 4 +- .../Portable/xlf/CSharpResources.cs.xlf | 5 + .../Portable/xlf/CSharpResources.de.xlf | 5 + .../Portable/xlf/CSharpResources.es.xlf | 5 + .../Portable/xlf/CSharpResources.fr.xlf | 5 + .../Portable/xlf/CSharpResources.it.xlf | 5 + .../Portable/xlf/CSharpResources.ja.xlf | 5 + .../Portable/xlf/CSharpResources.ko.xlf | 5 + .../Portable/xlf/CSharpResources.pl.xlf | 5 + .../Portable/xlf/CSharpResources.pt-BR.xlf | 5 + .../Portable/xlf/CSharpResources.ru.xlf | 5 + .../Portable/xlf/CSharpResources.tr.xlf | 5 + .../Portable/xlf/CSharpResources.zh-Hans.xlf | 5 + .../Portable/xlf/CSharpResources.zh-Hant.xlf | 5 + .../CodeGen/CodeGenFunctionPointersTests.cs | 35 +- .../DiagnosticAnalyzerTests.AllInOne.cs | 1 - .../Semantics/FunctionPointerTests.cs | 42 +- .../Symbols/FunctionPointerTypeSymbolTests.cs | 26 +- .../Generated/Syntax.Test.xml.Generated.cs | 22 +- .../Syntax/Parsing/FunctionPointerTests.cs | 2559 +++++++++++------ .../Core/Portable/PEWriter/Members.cs | 7 + .../CSharp/FunctionPointerUtilities.cs | 6 +- src/Test/Utilities/Portable/TestResource.resx | 6 +- .../ContextQuery/SyntaxTreeExtensions.cs | 2 +- ...olExtensions.TypeSyntaxGeneratorVisitor.cs | 4 +- 37 files changed, 2235 insertions(+), 1149 deletions(-) diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx index 75be7ee27ce4b..21f66e1a4b671 100644 --- a/src/Compilers/CSharp/Portable/CSharpResources.resx +++ b/src/Compilers/CSharp/Portable/CSharpResources.resx @@ -6250,6 +6250,9 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ Cannot convert &method group '{0}' to non-function pointer type '{1}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + Feature '{0}' is not available in C# 9.0. Please use language version {1} or greater. diff --git a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs index e62a5b913912e..b145b9ee0c01b 100644 --- a/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs +++ b/src/Compilers/CSharp/Portable/Errors/ErrorCode.cs @@ -1860,6 +1860,11 @@ internal enum ErrorCode ERR_DoesNotOverrideBaseEquals = 8871, #endregion diagnostics introduced for C# 9.0 + + // PROTOTYPE(func-ptr): Pack before merge + + ERR_CannotSpecifyManagedWithUnmanagedSpecifiers = 9500, + // Note: you will need to re-generate compiler code after adding warnings (eng\generate-compiler-code.cmd) } } diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 4c7e6f75c45ac..4cd89ee2e75c1 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1054,9 +1054,9 @@ internal sealed partial class FunctionPointerTypeSyntax : TypeSyntax internal readonly SyntaxToken delegateKeyword; internal readonly SyntaxToken asteriskToken; internal readonly FunctionPointerCallingConventionSyntax? callingConvention; - internal readonly FunctionPointerParameterList parameters; + internal readonly FunctionPointerParameterList parameterList; - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 4; @@ -1069,11 +1069,11 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; + this.AdjustFlagsAndWidth(parameterList); + this.parameterList = parameterList; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters, SyntaxFactoryContext context) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); @@ -1087,11 +1087,11 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; + this.AdjustFlagsAndWidth(parameterList); + this.parameterList = parameterList; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) : base(kind) { this.SlotCount = 4; @@ -1104,8 +1104,8 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - this.AdjustFlagsAndWidth(parameters); - this.parameters = parameters; + this.AdjustFlagsAndWidth(parameterList); + this.parameterList = parameterList; } /// SyntaxToken representing the delegate keyword. @@ -1115,7 +1115,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, /// SyntaxToken representing the optional calling convention. public FunctionPointerCallingConventionSyntax? CallingConvention => this.callingConvention; /// List of the parameter types and return type of the function pointer. - public FunctionPointerParameterList Parameters => this.parameters; + public FunctionPointerParameterList ParameterList => this.parameterList; internal override GreenNode? GetSlot(int index) => index switch @@ -1123,7 +1123,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, 0 => this.delegateKeyword, 1 => this.asteriskToken, 2 => this.callingConvention, - 3 => this.parameters, + 3 => this.parameterList, _ => null, }; @@ -1132,11 +1132,11 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax callingConvention, FunctionPointerParameterList parameters) + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax callingConvention, FunctionPointerParameterList parameterList) { - if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameters != this.Parameters) + if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameterList != this.ParameterList) { - var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameters); + var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameterList); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1150,10 +1150,10 @@ public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameters, diagnostics, GetAnnotations()); + => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameterList, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameters, GetDiagnostics(), annotations); + => new FunctionPointerTypeSyntax(this.Kind, this.delegateKeyword, this.asteriskToken, this.callingConvention, this.parameterList, GetDiagnostics(), annotations); internal FunctionPointerTypeSyntax(ObjectReader reader) : base(reader) @@ -1171,9 +1171,9 @@ internal FunctionPointerTypeSyntax(ObjectReader reader) AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - var parameters = (FunctionPointerParameterList)reader.ReadValue(); - AdjustFlagsAndWidth(parameters); - this.parameters = parameters; + var parameterList = (FunctionPointerParameterList)reader.ReadValue(); + AdjustFlagsAndWidth(parameterList); + this.parameterList = parameterList; } internal override void WriteTo(ObjectWriter writer) @@ -1182,7 +1182,7 @@ internal override void WriteTo(ObjectWriter writer) writer.WriteValue(this.delegateKeyword); writer.WriteValue(this.asteriskToken); writer.WriteValue(this.callingConvention); - writer.WriteValue(this.parameters); + writer.WriteValue(this.parameterList); } static FunctionPointerTypeSyntax() @@ -1324,58 +1324,58 @@ static FunctionPointerParameterList() internal sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode { internal readonly SyntaxToken managedSpecifier; - internal readonly FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers; + internal readonly FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList; - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 2; this.AdjustFlagsAndWidth(managedSpecifier); this.managedSpecifier = managedSpecifier; - if (unmanagedCallingConventionSpecifiers != null) + if (unmanagedCallingConventionList != null) { - this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); - this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + this.AdjustFlagsAndWidth(unmanagedCallingConventionList); + this.unmanagedCallingConventionList = unmanagedCallingConventionList; } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers, SyntaxFactoryContext context) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); this.SlotCount = 2; this.AdjustFlagsAndWidth(managedSpecifier); this.managedSpecifier = managedSpecifier; - if (unmanagedCallingConventionSpecifiers != null) + if (unmanagedCallingConventionList != null) { - this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); - this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + this.AdjustFlagsAndWidth(unmanagedCallingConventionList); + this.unmanagedCallingConventionList = unmanagedCallingConventionList; } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) : base(kind) { this.SlotCount = 2; this.AdjustFlagsAndWidth(managedSpecifier); this.managedSpecifier = managedSpecifier; - if (unmanagedCallingConventionSpecifiers != null) + if (unmanagedCallingConventionList != null) { - this.AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); - this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + this.AdjustFlagsAndWidth(unmanagedCallingConventionList); + this.unmanagedCallingConventionList = unmanagedCallingConventionList; } } /// SyntaxToken representing whether the calling convention is managed or unmanaged. public SyntaxToken ManagedSpecifier => this.managedSpecifier; /// Optional list of identifiers that will contribute to an unmanaged calling convention. - public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionSpecifiers => this.unmanagedCallingConventionSpecifiers; + public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionList => this.unmanagedCallingConventionList; internal override GreenNode? GetSlot(int index) => index switch { 0 => this.managedSpecifier, - 1 => this.unmanagedCallingConventionSpecifiers, + 1 => this.unmanagedCallingConventionList, _ => null, }; @@ -1384,11 +1384,11 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionSpecifiers) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) { - if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionSpecifiers != this.UnmanagedCallingConventionSpecifiers) + if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { - var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionSpecifiers); + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionList); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1402,10 +1402,10 @@ public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifie } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionSpecifiers, diagnostics, GetAnnotations()); + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionList, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionSpecifiers, GetDiagnostics(), annotations); + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionList, GetDiagnostics(), annotations); internal FunctionPointerCallingConventionSyntax(ObjectReader reader) : base(reader) @@ -1414,11 +1414,11 @@ internal FunctionPointerCallingConventionSyntax(ObjectReader reader) var managedSpecifier = (SyntaxToken)reader.ReadValue(); AdjustFlagsAndWidth(managedSpecifier); this.managedSpecifier = managedSpecifier; - var unmanagedCallingConventionSpecifiers = (FunctionPointerUnmanagedCallingConventionSyntaxList?)reader.ReadValue(); - if (unmanagedCallingConventionSpecifiers != null) + var unmanagedCallingConventionList = (FunctionPointerUnmanagedCallingConventionSyntaxList?)reader.ReadValue(); + if (unmanagedCallingConventionList != null) { - AdjustFlagsAndWidth(unmanagedCallingConventionSpecifiers); - this.unmanagedCallingConventionSpecifiers = unmanagedCallingConventionSpecifiers; + AdjustFlagsAndWidth(unmanagedCallingConventionList); + this.unmanagedCallingConventionList = unmanagedCallingConventionList; } } @@ -1426,7 +1426,7 @@ internal override void WriteTo(ObjectWriter writer) { base.WriteTo(writer); writer.WriteValue(this.managedSpecifier); - writer.WriteValue(this.unmanagedCallingConventionSpecifiers); + writer.WriteValue(this.unmanagedCallingConventionList); } static FunctionPointerCallingConventionSyntax() @@ -1567,49 +1567,49 @@ static FunctionPointerUnmanagedCallingConventionSyntaxList() /// Individual function pointer unmanaged calling convention. internal sealed partial class FunctionPointerUnmanagedCallingConventionSyntax : CSharpSyntaxNode { - internal readonly SyntaxToken callingConvention; + internal readonly SyntaxToken name; - internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken name, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 1; - this.AdjustFlagsAndWidth(callingConvention); - this.callingConvention = callingConvention; + this.AdjustFlagsAndWidth(name); + this.name = name; } - internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention, SyntaxFactoryContext context) + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken name, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); this.SlotCount = 1; - this.AdjustFlagsAndWidth(callingConvention); - this.callingConvention = callingConvention; + this.AdjustFlagsAndWidth(name); + this.name = name; } - internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken callingConvention) + internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, SyntaxToken name) : base(kind) { this.SlotCount = 1; - this.AdjustFlagsAndWidth(callingConvention); - this.callingConvention = callingConvention; + this.AdjustFlagsAndWidth(name); + this.name = name; } /// SyntaxToken the calling convention identifier. - public SyntaxToken CallingConvention => this.callingConvention; + public SyntaxToken Name => this.name; internal override GreenNode? GetSlot(int index) - => index == 0 ? this.callingConvention : null; + => index == 0 ? this.name : null; internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax(this, parent, position); public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); - public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callingConvention) + public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken name) { - if (callingConvention != this.CallingConvention) + if (name != this.Name) { - var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(callingConvention); + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(name); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1623,24 +1623,24 @@ public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callin } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.callingConvention, diagnostics, GetAnnotations()); + => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.name, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.callingConvention, GetDiagnostics(), annotations); + => new FunctionPointerUnmanagedCallingConventionSyntax(this.Kind, this.name, GetDiagnostics(), annotations); internal FunctionPointerUnmanagedCallingConventionSyntax(ObjectReader reader) : base(reader) { this.SlotCount = 1; - var callingConvention = (SyntaxToken)reader.ReadValue(); - AdjustFlagsAndWidth(callingConvention); - this.callingConvention = callingConvention; + var name = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(name); + this.name = name; } internal override void WriteTo(ObjectWriter writer) { base.WriteTo(writer); - writer.WriteValue(this.callingConvention); + writer.WriteValue(this.name); } static FunctionPointerUnmanagedCallingConventionSyntax() @@ -33369,19 +33369,19 @@ public override CSharpSyntaxNode VisitPointerType(PointerTypeSyntax node) => node.Update((TypeSyntax)Visit(node.ElementType), (SyntaxToken)Visit(node.AsteriskToken)); public override CSharpSyntaxNode VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (FunctionPointerCallingConventionSyntax)Visit(node.CallingConvention), (FunctionPointerParameterList)Visit(node.Parameters)); + => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (FunctionPointerCallingConventionSyntax)Visit(node.CallingConvention), (FunctionPointerParameterList)Visit(node.ParameterList)); public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPointerParameterList node) => node.Update((SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); public override CSharpSyntaxNode VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList)Visit(node.UnmanagedCallingConventionSpecifiers)); + => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList)Visit(node.UnmanagedCallingConventionList)); public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => node.Update((SyntaxToken)Visit(node.OpenBracketToken), VisitList(node.CallingConventions), (SyntaxToken)Visit(node.CloseBracketToken)); public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) - => node.Update((SyntaxToken)Visit(node.CallingConvention)); + => node.Update((SyntaxToken)Visit(node.Name)); public override CSharpSyntaxNode VisitNullableType(NullableTypeSyntax node) => node.Update((TypeSyntax)Visit(node.ElementType), (SyntaxToken)Visit(node.QuestionToken)); @@ -34252,17 +34252,17 @@ public PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken asteris return result; } - public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); if (delegateKeyword.Kind != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken == null) throw new ArgumentNullException(nameof(asteriskToken)); if (asteriskToken.Kind != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); - if (parameters == null) throw new ArgumentNullException(nameof(parameters)); + if (parameterList == null) throw new ArgumentNullException(nameof(parameterList)); #endif - return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameters, this.context); + return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList, this.context); } public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) @@ -34287,7 +34287,7 @@ public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken les return result; } - public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) { #if DEBUG if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); @@ -34300,10 +34300,10 @@ public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(S #endif int hash; - var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, this.context, out hash); + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, this.context, out hash); if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; - var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, this.context); + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, this.context); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -34334,18 +34334,18 @@ public FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmana return result; } - public FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + public FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name) { #if DEBUG - if (callingConvention == null) throw new ArgumentNullException(nameof(callingConvention)); - if (callingConvention.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); + if (name == null) throw new ArgumentNullException(nameof(name)); + if (name.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(name)); #endif int hash; - var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, this.context, out hash); + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, name, this.context, out hash); if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntax)cached; - var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, this.context); + var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, name, this.context); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -39127,17 +39127,17 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken return result; } - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); if (delegateKeyword.Kind != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken == null) throw new ArgumentNullException(nameof(asteriskToken)); if (asteriskToken.Kind != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); - if (parameters == null) throw new ArgumentNullException(nameof(parameters)); + if (parameterList == null) throw new ArgumentNullException(nameof(parameterList)); #endif - return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameters); + return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList); } public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) @@ -39162,7 +39162,7 @@ public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxTo return result; } - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) { #if DEBUG if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); @@ -39175,10 +39175,10 @@ public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConve #endif int hash; - var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers, out hash); + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, out hash); if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; - var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConventionList, managedSpecifier, unmanagedCallingConventionSpecifiers); + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -39209,18 +39209,18 @@ public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointe return result; } - public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name) { #if DEBUG - if (callingConvention == null) throw new ArgumentNullException(nameof(callingConvention)); - if (callingConvention.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); + if (name == null) throw new ArgumentNullException(nameof(name)); + if (name.Kind != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(name)); #endif int hash; - var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention, out hash); + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConvention, name, out hash); if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntax)cached; - var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, callingConvention); + var result = new FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConvention, name); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs index 3f54eb59933b5..bf1ad5cba66b0 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs @@ -1659,19 +1659,19 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor => node.Update((TypeSyntax?)Visit(node.ElementType) ?? throw new ArgumentNullException("elementType"), VisitToken(node.AsteriskToken)); public override SyntaxNode? VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), (FunctionPointerCallingConventionSyntax?)Visit(node.CallingConvention), (FunctionPointerParameterList?)Visit(node.Parameters) ?? throw new ArgumentNullException("parameters")); + => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), (FunctionPointerCallingConventionSyntax?)Visit(node.CallingConvention), (FunctionPointerParameterList?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList")); public override SyntaxNode? VisitFunctionPointerParameterList(FunctionPointerParameterList node) => node.Update(VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); public override SyntaxNode? VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList?)Visit(node.UnmanagedCallingConventionSpecifiers)); + => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList?)Visit(node.UnmanagedCallingConventionList)); public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => node.Update(VisitToken(node.OpenBracketToken), VisitList(node.CallingConventions), VisitToken(node.CloseBracketToken)); public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) - => node.Update(VisitToken(node.CallingConvention)); + => node.Update(VisitToken(node.Name)); public override SyntaxNode? VisitNullableType(NullableTypeSyntax node) => node.Update((TypeSyntax?)Visit(node.ElementType) ?? throw new ArgumentNullException("elementType"), VisitToken(node.QuestionToken)); @@ -2456,17 +2456,17 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType) => SyntaxFactory.PointerType(elementType, SyntaxFactory.Token(SyntaxKind.AsteriskToken)); /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) { if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken.Kind() != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); - if (parameters == null) throw new ArgumentNullException(nameof(parameters)); - return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, callingConvention == null ? null : (Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)callingConvention.Green, (Syntax.InternalSyntax.FunctionPointerParameterList)parameters.Green).CreateRed(); + if (parameterList == null) throw new ArgumentNullException(nameof(parameterList)); + return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, callingConvention == null ? null : (Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)callingConvention.Green, (Syntax.InternalSyntax.FunctionPointerParameterList)parameterList.Green).CreateRed(); } /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) - => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameters); + public static FunctionPointerTypeSyntax FunctionPointerType(FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameterList); /// Creates a new FunctionPointerTypeSyntax instance. public static FunctionPointerTypeSyntax FunctionPointerType() @@ -2485,7 +2485,7 @@ public static FunctionPointerParameterList FunctionPointerParameterList(Separate => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); /// Creates a new FunctionPointerCallingConventionSyntax instance. - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) { switch (managedSpecifier.Kind()) { @@ -2493,7 +2493,7 @@ public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConve case SyntaxKind.UnmanagedKeyword: break; default: throw new ArgumentException(nameof(managedSpecifier)); } - return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionSpecifiers == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)unmanagedCallingConventionSpecifiers.Green).CreateRed(); + return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionList == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)unmanagedCallingConventionList.Green).CreateRed(); } /// Creates a new FunctionPointerCallingConventionSyntax instance. @@ -2513,10 +2513,10 @@ public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointe => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); /// Creates a new FunctionPointerUnmanagedCallingConventionSyntax instance. - public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken callingConvention) + public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name) { - if (callingConvention.Kind() != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(callingConvention)); - return (FunctionPointerUnmanagedCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConvention((Syntax.InternalSyntax.SyntaxToken)callingConvention.Node!).CreateRed(); + if (name.Kind() != SyntaxKind.IdentifierToken) throw new ArgumentException(nameof(name)); + return (FunctionPointerUnmanagedCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConvention((Syntax.InternalSyntax.SyntaxToken)name.Node!).CreateRed(); } /// Creates a new NullableTypeSyntax instance. diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index 0fc07a880d816..84301c14fbab6 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -468,7 +468,7 @@ public PointerTypeSyntax Update(TypeSyntax elementType, SyntaxToken asteriskToke public sealed partial class FunctionPointerTypeSyntax : TypeSyntax { private FunctionPointerCallingConventionSyntax? callingConvention; - private FunctionPointerParameterList? parameters; + private FunctionPointerParameterList? parameterList; internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) @@ -485,13 +485,13 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax public FunctionPointerCallingConventionSyntax? CallingConvention => GetRed(ref this.callingConvention, 2); /// List of the parameter types and return type of the function pointer. - public FunctionPointerParameterList Parameters => GetRed(ref this.parameters, 3)!; + public FunctionPointerParameterList ParameterList => GetRed(ref this.parameterList, 3)!; internal override SyntaxNode? GetNodeSlot(int index) => index switch { 2 => GetRed(ref this.callingConvention, 2), - 3 => GetRed(ref this.parameters, 3)!, + 3 => GetRed(ref this.parameterList, 3)!, _ => null, }; @@ -499,7 +499,7 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax => index switch { 2 => this.callingConvention, - 3 => this.parameters, + 3 => this.parameterList, _ => null, }; @@ -507,11 +507,11 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameters) + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) { - if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameters != this.Parameters) + if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameterList != this.ParameterList) { - var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameters); + var newNode = SyntaxFactory.FunctionPointerType(delegateKeyword, asteriskToken, callingConvention, parameterList); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -519,12 +519,12 @@ public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken return this; } - public FunctionPointerTypeSyntax WithDelegateKeyword(SyntaxToken delegateKeyword) => Update(delegateKeyword, this.AsteriskToken, this.CallingConvention, this.Parameters); - public FunctionPointerTypeSyntax WithAsteriskToken(SyntaxToken asteriskToken) => Update(this.DelegateKeyword, asteriskToken, this.CallingConvention, this.Parameters); - public FunctionPointerTypeSyntax WithCallingConvention(FunctionPointerCallingConventionSyntax? callingConvention) => Update(this.DelegateKeyword, this.AsteriskToken, callingConvention, this.Parameters); - public FunctionPointerTypeSyntax WithParameters(FunctionPointerParameterList parameters) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, parameters); + public FunctionPointerTypeSyntax WithDelegateKeyword(SyntaxToken delegateKeyword) => Update(delegateKeyword, this.AsteriskToken, this.CallingConvention, this.ParameterList); + public FunctionPointerTypeSyntax WithAsteriskToken(SyntaxToken asteriskToken) => Update(this.DelegateKeyword, asteriskToken, this.CallingConvention, this.ParameterList); + public FunctionPointerTypeSyntax WithCallingConvention(FunctionPointerCallingConventionSyntax? callingConvention) => Update(this.DelegateKeyword, this.AsteriskToken, callingConvention, this.ParameterList); + public FunctionPointerTypeSyntax WithParameterList(FunctionPointerParameterList parameterList) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, parameterList); - public FunctionPointerTypeSyntax AddParametersParameters(params FunctionPointerParameterSyntax[] items) => WithParameters(this.Parameters.WithParameters(this.Parameters.Parameters.AddRange(items))); + public FunctionPointerTypeSyntax AddParameterListParameters(params FunctionPointerParameterSyntax[] items) => WithParameterList(this.ParameterList.WithParameters(this.ParameterList.Parameters.AddRange(items))); } /// Function pointer parameter list syntax. @@ -583,7 +583,7 @@ public FunctionPointerParameterList Update(SyntaxToken lessThanToken, SeparatedS /// Function pointer calling convention syntax. public sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode { - private FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers; + private FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList; internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) @@ -594,21 +594,21 @@ internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode public SyntaxToken ManagedSpecifier => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)this.Green).managedSpecifier, Position, 0); /// Optional list of identifiers that will contribute to an unmanaged calling convention. - public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionSpecifiers => GetRed(ref this.unmanagedCallingConventionSpecifiers, 1); + public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionList => GetRed(ref this.unmanagedCallingConventionList, 1); - internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.unmanagedCallingConventionSpecifiers, 1) : null; + internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.unmanagedCallingConventionList, 1) : null; - internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.unmanagedCallingConventionSpecifiers : null; + internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.unmanagedCallingConventionList : null; public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) { - if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionSpecifiers != this.UnmanagedCallingConventionSpecifiers) + if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { - var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionSpecifiers); + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionList); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -616,13 +616,13 @@ public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifie return this; } - public FunctionPointerCallingConventionSyntax WithManagedSpecifier(SyntaxToken managedSpecifier) => Update(managedSpecifier, this.UnmanagedCallingConventionSpecifiers); - public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionSpecifiers(FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionSpecifiers) => Update(this.ManagedSpecifier, unmanagedCallingConventionSpecifiers); + public FunctionPointerCallingConventionSyntax WithManagedSpecifier(SyntaxToken managedSpecifier) => Update(managedSpecifier, this.UnmanagedCallingConventionList); + public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) => Update(this.ManagedSpecifier, unmanagedCallingConventionList); - public FunctionPointerCallingConventionSyntax AddUnmanagedCallingConventionSpecifiersCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) + public FunctionPointerCallingConventionSyntax AddUnmanagedCallingConventionListCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) { - var unmanagedCallingConventionSpecifiers = this.UnmanagedCallingConventionSpecifiers ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(); - return WithUnmanagedCallingConventionSpecifiers(unmanagedCallingConventionSpecifiers.WithCallingConventions(unmanagedCallingConventionSpecifiers.CallingConventions.AddRange(items))); + var unmanagedCallingConventionList = this.UnmanagedCallingConventionList ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(); + return WithUnmanagedCallingConventionList(unmanagedCallingConventionList.WithCallingConventions(unmanagedCallingConventionList.CallingConventions.AddRange(items))); } } @@ -688,7 +688,7 @@ internal FunctionPointerUnmanagedCallingConventionSyntax(InternalSyntax.CSharpSy } /// SyntaxToken the calling convention identifier. - public SyntaxToken CallingConvention => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax)this.Green).callingConvention, Position, 0); + public SyntaxToken Name => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax)this.Green).name, Position, 0); internal override SyntaxNode? GetNodeSlot(int index) => null; @@ -698,11 +698,11 @@ internal FunctionPointerUnmanagedCallingConventionSyntax(InternalSyntax.CSharpSy [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConvention(this); - public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callingConvention) + public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken name) { - if (callingConvention != this.CallingConvention) + if (name != this.Name) { - var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(callingConvention); + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConvention(name); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -710,7 +710,7 @@ public FunctionPointerUnmanagedCallingConventionSyntax Update(SyntaxToken callin return this; } - public FunctionPointerUnmanagedCallingConventionSyntax WithCallingConvention(SyntaxToken callingConvention) => Update(callingConvention); + public FunctionPointerUnmanagedCallingConventionSyntax WithName(SyntaxToken name) => Update(name); } /// Class which represents the syntax node for a nullable type. diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs index 53d6fe582c8be..38f8cb3a03af1 100644 --- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs +++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs @@ -83,9 +83,10 @@ internal enum TerminatorState IsEndOfNameInExplicitInterface = 1 << 22, IsEndOfFunctionPointerParameterList = 1 << 23, IsEndOfFunctionPointerParameterListErrored = 1 << 24, + IsEndOfFunctionPointerCallingConvention = 1 << 25, } - private const int LastTerminatorState = (int)TerminatorState.IsEndOfFunctionPointerParameterListErrored; + private const int LastTerminatorState = (int)TerminatorState.IsEndOfFunctionPointerCallingConvention; private bool IsTerminator() { @@ -123,6 +124,7 @@ private bool IsTerminator() case TerminatorState.IsEndOfNameInExplicitInterface when this.IsEndOfNameInExplicitInterface(): case TerminatorState.IsEndOfFunctionPointerParameterList when this.IsEndOfFunctionPointerParameterList(errored: false): case TerminatorState.IsEndOfFunctionPointerParameterListErrored when this.IsEndOfFunctionPointerParameterList(errored: true): + case TerminatorState.IsEndOfFunctionPointerCallingConvention when this.IsEndOfFunctionPointerCallingConvention(): return true; } } @@ -3030,6 +3032,8 @@ private bool IsEndOfNameInExplicitInterface() private bool IsEndOfFunctionPointerParameterList(bool errored) => this.CurrentToken.Kind == (errored ? SyntaxKind.CloseParenToken : SyntaxKind.GreaterThanToken); + private bool IsEndOfFunctionPointerCallingConvention() => this.CurrentToken.Kind == SyntaxKind.CloseBracketToken; + private MethodDeclarationSyntax ParseMethodDeclaration( SyntaxList attributes, SyntaxListBuilder modifiers, @@ -6393,9 +6397,52 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) _ = EatToken(SyntaxKind.DelegateKeyword); lastTokenOfType = EatToken(SyntaxKind.AsteriskToken); - if (IsPossibleCallingConvention(lastTokenOfType)) + TerminatorState saveTerm; + + if (CurrentToken.Kind == SyntaxKind.IdentifierToken) { - lastTokenOfType = EatToken(); + switch (CurrentToken) + { + case { ContextualKind: SyntaxKind.ManagedKeyword }: + case { ContextualKind: SyntaxKind.UnmanagedKeyword }: + case var _ when PeekToken(1).Kind == SyntaxKind.OpenBracketToken: + lastTokenOfType = EatToken(); + break; + + default: + // Whatever is next, it's probably not part of the type. We know that delegate* must be + // a function pointer start, however, so say the asterisk is the last element and bail + return ScanTypeFlags.MustBeType; + } + + if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) + { + lastTokenOfType = EatToken(SyntaxKind.OpenBracketToken); + saveTerm = _termState; + _termState |= TerminatorState.IsEndOfFunctionPointerCallingConvention; + + try + { + while (true) + { + lastTokenOfType = EatToken(SyntaxKind.IdentifierToken); + + if (skipBadFunctionPointerTokens() == PostSkipAction.Abort) + { + break; + } + + Debug.Assert(CurrentToken.Kind == SyntaxKind.CommaToken); + lastTokenOfType = EatToken(); + } + + lastTokenOfType = EatToken(SyntaxKind.CloseBracketToken); + } + finally + { + _termState = saveTerm; + } + } } if (!IsPossibleFunctionPointerParameterListStart(CurrentToken)) @@ -6410,26 +6457,20 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) var validStartingToken = EatToken().Kind == SyntaxKind.LessThanToken; - var saveTerm = _termState; + saveTerm = _termState; _termState |= validStartingToken ? TerminatorState.IsEndOfFunctionPointerParameterList : TerminatorState.IsEndOfFunctionPointerParameterListErrored; + var ignoredModifiers = _pool.Allocate(); try { do { - var ignoredModifiers = _pool.Allocate(); - try - { - ParseParameterModifiers(ignoredModifiers, isFunctionPointerParameter: true); - } - finally - { - _pool.Free(ignoredModifiers); - } + ParseParameterModifiers(ignoredModifiers, isFunctionPointerParameter: true); + ignoredModifiers.Clear(); _ = ScanType(out _); - if (skipBadFunctionPointerParameterTokens() == PostSkipAction.Abort) + if (skipBadFunctionPointerTokens() == PostSkipAction.Abort) { break; } @@ -6441,6 +6482,7 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) finally { _termState = saveTerm; + _pool.Free(ignoredModifiers); } if (!validStartingToken && CurrentToken.Kind == SyntaxKind.CloseParenToken) @@ -6454,7 +6496,7 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) return ScanTypeFlags.MustBeType; - PostSkipAction skipBadFunctionPointerParameterTokens() + PostSkipAction skipBadFunctionPointerTokens() { return SkipBadTokensWithExpectedKind(isNotExpectedFunction: p => p.CurrentToken.Kind != SyntaxKind.CommaToken, abortFunction: p => p.IsTerminator(), @@ -6880,21 +6922,21 @@ private FunctionPointerTypeSyntax ParseFunctionPointerTypeSyntax() Debug.Assert(IsFunctionPointerStart()); var @delegate = EatToken(SyntaxKind.DelegateKeyword); var asterisk = EatToken(SyntaxKind.AsteriskToken); - // Invalid calling conventions will be reported at type binding time - var callingConvention = IsPossibleCallingConvention(asterisk) ? EatToken() : null; + + FunctionPointerCallingConventionSyntax? callingConvention = parseCallingConvention(); if (!IsPossibleFunctionPointerParameterListStart(CurrentToken)) { var lessThanTokenError = WithAdditionalDiagnostics(SyntaxFactory.MissingToken(SyntaxKind.LessThanToken), GetExpectedTokenError(SyntaxKind.LessThanToken, SyntaxKind.None)); - var missingTypes = _pool.AllocateSeparated(); + var missingTypes = _pool.AllocateSeparated(); var missingTypeName = CreateMissingIdentifierName(); - var missingType = SyntaxFactory.Parameter(attributeLists: default, modifiers: default, missingTypeName, identifier: CreateMissingIdentifierToken(), @default: null); + var missingType = SyntaxFactory.FunctionPointerParameter(attributeLists: default, modifiers: default, missingTypeName); missingTypes.Add(missingType); // Handle the simple case of delegate*>. We don't try to deal with any variation of delegate*invalid>, as // we don't know for sure that the expression isn't a relational with something else. var greaterThanTokenError = TryEatToken(SyntaxKind.GreaterThanToken) ?? SyntaxFactory.MissingToken(SyntaxKind.GreaterThanToken); - - var funcPtr = SyntaxFactory.FunctionPointerType(@delegate, asterisk, callingConvention, lessThanTokenError, missingTypes, greaterThanTokenError); + var paramList = SyntaxFactory.FunctionPointerParameterList(lessThanTokenError, missingTypes, greaterThanTokenError); + var funcPtr = SyntaxFactory.FunctionPointerType(@delegate, asterisk, callingConvention, paramList); _pool.Free(missingTypes); return funcPtr; } @@ -6902,7 +6944,7 @@ private FunctionPointerTypeSyntax ParseFunctionPointerTypeSyntax() var lessThanToken = EatTokenAsKind(SyntaxKind.LessThanToken); var saveTerm = _termState; _termState |= (lessThanToken.IsMissing ? TerminatorState.IsEndOfFunctionPointerParameterListErrored : TerminatorState.IsEndOfFunctionPointerParameterList); - var types = _pool.AllocateSeparated(); + var types = _pool.AllocateSeparated(); try { @@ -6914,9 +6956,9 @@ private FunctionPointerTypeSyntax ParseFunctionPointerTypeSyntax() ParseParameterModifiers(modifiers, isFunctionPointerParameter: true); var parameterType = ParseTypeOrVoid(); - types.Add(SyntaxFactory.Parameter(attributeLists: default, modifiers, parameterType, identifier: CreateMissingIdentifierToken(), @default: null)); + types.Add(SyntaxFactory.FunctionPointerParameter(attributeLists: default, modifiers, parameterType)); - if (skipBadFunctionPointerParameterListTokens() == PostSkipAction.Abort) + if (skipBadFunctionPointerTokens(types) == PostSkipAction.Abort) { break; } @@ -6940,7 +6982,7 @@ private FunctionPointerTypeSyntax ParseFunctionPointerTypeSyntax() greaterThanToken = EatToken(SyntaxKind.GreaterThanToken); } - var funcPointer = SyntaxFactory.FunctionPointerType(@delegate, asterisk, callingConvention, lessThanToken, types, greaterThanToken); + var funcPointer = SyntaxFactory.FunctionPointerType(@delegate, asterisk, callingConvention, SyntaxFactory.FunctionPointerParameterList(lessThanToken, types, greaterThanToken)); funcPointer = CheckFeatureAvailability(funcPointer, MessageID.IDS_FeatureFunctionPointers); return funcPointer; } @@ -6950,76 +6992,90 @@ private FunctionPointerTypeSyntax ParseFunctionPointerTypeSyntax() _pool.Free(types); } - PostSkipAction skipBadFunctionPointerParameterListTokens() + PostSkipAction skipBadFunctionPointerTokens(SeparatedSyntaxListBuilder list) where T : CSharpSyntaxNode { CSharpSyntaxNode? tmp = null; - Debug.Assert(types.Count > 0); + Debug.Assert(list.Count > 0); return SkipBadSeparatedListTokensWithExpectedKind(ref tmp, - types, + list, isNotExpectedFunction: p => p.CurrentToken.Kind != SyntaxKind.CommaToken, abortFunction: p => p.IsTerminator(), expected: SyntaxKind.CommaToken); } - } - - private bool IsFunctionPointerStart() - => CurrentToken.Kind == SyntaxKind.DelegateKeyword && PeekToken(1).Kind == SyntaxKind.AsteriskToken; - private bool IsPossibleCallingConvention(SyntaxToken asteriskToken) - { - if (IsPossibleFunctionPointerParameterListStart(CurrentToken)) + FunctionPointerCallingConventionSyntax? parseCallingConvention() { - return false; - } + if (CurrentToken.Kind == SyntaxKind.IdentifierToken) + { + SyntaxToken managedSpecifier; + switch (CurrentToken) + { + case { ContextualKind: SyntaxKind.ManagedKeyword }: + case { ContextualKind: SyntaxKind.UnmanagedKeyword }: + managedSpecifier = EatContextualToken(CurrentToken.ContextualKind); + break; - // If the next token is a known function pointer calling convention, treat it as a - // calling convention no matter what. If it wasn't intended to be a calling convention - // we'd have an error anyway, and it's more likely the user intended for it to be a - // function pointer convention than not. - if (FunctionPointerTypeSymbol.GetCallingConvention(CurrentToken.Text).IsValid) - { - return true; - } + case var _ when PeekToken(1).Kind == SyntaxKind.OpenBracketToken: + // If there's an open brace next, treat this as a bad identifier that should have been unmanaged + managedSpecifier = EatTokenAsKind(SyntaxKind.UnmanagedKeyword); + break; - // For nicer error recovery, we only treat predefined types and identifiers as if they could be the - // calling convention. For any other keyword, they're almost certainly part of some other - // construct, and would produce better errors if parsed separately. The user could have this: - // - // delegate* /* Declaration in progress */ while (true) {} - // - // The parse tree will look much better if the while(true) is considered a separate structure, - // even though it does look like it could be the start of an invalid function pointer definition. - if (CurrentToken.Kind != SyntaxKind.IdentifierToken && !IsPredefinedType(CurrentToken.Kind)) - { - return false; - } + default: + // Whatever is next, it's probably not a calling convention or a function pointer type. + // Bail out + return null; + } - // If the asterisk was at the end of the previous line and it's not a valid calling convention, - // chances are anything on a new line should not be considered part of the function pointer. - // For example: - // - // delegate* - // int myValue = 1; - // - // would be better interpreted if the int myValue = 1 is considered separately - if (asteriskToken.TrailingTrivia.Any((int)SyntaxKind.EndOfLineTrivia)) - { - return false; - } + FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventions = null; + if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) + { + var openBracket = EatToken(SyntaxKind.OpenBracketToken); + var callingConventionModifiers = _pool.AllocateSeparated(); + var saveTerm = _termState; + _termState |= TerminatorState.IsEndOfFunctionPointerCallingConvention; - // We attempt to make error recovery a little nicer here by only treating a single - // identifier token as a calling convention if the token afterwards is actually a - // possible start to the function pointer parameter list. The intuition is that, for - // some partial trees like this: - // - // (delegate*MyProperty.MyMethod(); - // - // The user is actually in the middle of adding a cast, and if we interpreted MyProperty - // as a calling convention, we'd get a much worse set of errors than if we treated the - // function pointer as having no calling convention. - return IsPossibleFunctionPointerParameterListStart(PeekToken(1)); + try + { + while (true) + { + callingConventionModifiers.Add(SyntaxFactory.FunctionPointerUnmanagedCallingConvention(EatToken(SyntaxKind.IdentifierToken))); + + if (skipBadFunctionPointerTokens(callingConventionModifiers) == PostSkipAction.Abort) + { + break; + } + + Debug.Assert(CurrentToken.Kind == SyntaxKind.CommaToken); + callingConventionModifiers.AddSeparator(EatToken(SyntaxKind.CommaToken)); + } + + var closeBracket = EatToken(SyntaxKind.CloseBracketToken); + + unmanagedCallingConventions = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracket, callingConventionModifiers, closeBracket); + } + finally + { + _termState = saveTerm; + _pool.Free(callingConventionModifiers); + } + } + + if (managedSpecifier.Kind == SyntaxKind.ManagedKeyword && unmanagedCallingConventions != null) + { + // 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + unmanagedCallingConventions = AddError(unmanagedCallingConventions, ErrorCode.ERR_CannotSpecifyManagedWithUnmanagedSpecifiers); + } + + return SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventions); + } + + return null; + } } + private bool IsFunctionPointerStart() + => CurrentToken.Kind == SyntaxKind.DelegateKeyword && PeekToken(1).Kind == SyntaxKind.AsteriskToken; + private static bool IsPossibleFunctionPointerParameterListStart(SyntaxToken token) // We consider both ( and < to be possible starts, in order to make error recovery more graceful // in the scenario where a user accidentally surrounds their function pointer type list with parens. diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs index 74edb264b4499..8b2356a067d95 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs @@ -22,24 +22,19 @@ internal sealed class FunctionPointerMethodSymbol : MethodSymbol public static FunctionPointerMethodSymbol CreateFromSource(FunctionPointerTypeSyntax syntax, Binder typeBinder, DiagnosticBag diagnostics, ConsList basesBeingResolved, bool suppressUseSiteDiagnostics) { - var (callingConvention, conventionIsValid) = FunctionPointerTypeSymbol.GetCallingConvention(syntax.CallingConvention.Text); - if (!conventionIsValid) - { - // '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - diagnostics.Add(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, syntax.CallingConvention.GetLocation(), syntax.CallingConvention.Text); - } + var callingConvention = getCallingConvention(syntax.CallingConvention, diagnostics); RefKind refKind = RefKind.None; TypeWithAnnotations returnType; var refReadonlyModifiers = ImmutableArray.Empty; - if (syntax.Parameters.Count == 0) + if (syntax.ParameterList.Parameters.Count == 0) { returnType = TypeWithAnnotations.Create(typeBinder.CreateErrorType()); } else { - var returnTypeParameter = syntax.Parameters[^1]; + var returnTypeParameter = syntax.ParameterList.Parameters[^1]; var modifiers = returnTypeParameter.Modifiers; for (int i = 0; i < modifiers.Count; i++) { @@ -98,6 +93,37 @@ public static FunctionPointerMethodSymbol CreateFromSource(FunctionPointerTypeSy typeBinder, diagnostics, suppressUseSiteDiagnostics); + + // PROTOTYPE(func-ptr): Do this right. Just making compatible changes for now + static CallingConvention getCallingConvention(FunctionPointerCallingConventionSyntax? callingConventionSyntax, DiagnosticBag diagnostics) + { + switch (callingConventionSyntax) + { + case null: + return CallingConvention.Default; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.ManagedKeyword } }: + Debug.Assert(callingConventionSyntax.UnmanagedCallingConventionList is null || callingConventionSyntax.ContainsDiagnostics); + return CallingConvention.Default; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Cdecl"): + return CallingConvention.CDecl; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Thiscall"): + return CallingConvention.ThisCall; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Fastcall"): + return CallingConvention.FastCall; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Stdcall"): + return CallingConvention.Standard; + case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: null }: + return CallingConvention.Unmanaged; + + default: + // PROTOTYPE(func-ptr): Handle the possible null and actually construct the correct convention + diagnostics.Add(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, callingConventionSyntax.GetLocation(), callingConventionSyntax.UnmanagedCallingConventionList!.CallingConventions[0].Name.Text); + return CallingConvention.Default; + } + + static bool isCallingConvention(FunctionPointerUnmanagedCallingConventionSyntaxList specifiers, string expected) + => specifiers.CallingConventions[0].Name.Text == expected; + } } /// @@ -322,11 +348,11 @@ private FunctionPointerMethodSymbol( RefKind = refKind; ReturnTypeWithAnnotations = returnType; - _parameters = syntax.Parameters.Count > 1 + _parameters = syntax.ParameterList.Parameters.Count > 1 ? ParameterHelpers.MakeFunctionPointerParameters( typeBinder, this, - syntax.Parameters, + syntax.ParameterList.Parameters, diagnostics, suppressUseSiteDiagnostics) : ImmutableArray.Empty; diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs index 3a7c4a3481812..3f1708b52ef0d 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerTypeSymbol.cs @@ -47,17 +47,6 @@ public FunctionPointerTypeSymbol SubstituteTypeSymbol( ImmutableArray> paramRefCustomModifiers) => new FunctionPointerTypeSymbol(Signature.SubstituteParameterSymbols(substitutedReturnType, substitutedParameterTypes, refCustomModifiers, paramRefCustomModifiers)); - public static (CallingConvention Convention, bool IsValid) GetCallingConvention(string convention) => - convention switch - { - "" => (CallingConvention.Default, true), - "cdecl" => (CallingConvention.CDecl, true), - "managed" => (CallingConvention.Default, true), - "thiscall" => (CallingConvention.ThisCall, true), - "stdcall" => (CallingConvention.Standard, true), - _ => (CallingConvention.Default, false), - }; - private FunctionPointerTypeSymbol(FunctionPointerMethodSymbol signature) { Signature = signature; diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs index 6e69e47f0a6fe..b039b34a29b07 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs @@ -24,7 +24,7 @@ public static ImmutableArray MakeParameters( bool allowThis, bool addRefReadOnlyModifier) { - return MakeParameters( + return MakeParameters( binder, owner, syntax.Parameters, @@ -59,11 +59,11 @@ public static ImmutableArray MakeParameters( public static ImmutableArray MakeFunctionPointerParameters( Binder binder, FunctionPointerMethodSymbol owner, - SeparatedSyntaxList parametersList, + SeparatedSyntaxList parametersList, DiagnosticBag diagnostics, bool suppressUseSiteDiagnostics) { - return MakeParameters( + return MakeParameters( binder, owner, parametersList, @@ -75,7 +75,7 @@ public static ImmutableArray MakeFunctionPointer suppressUseSiteDiagnostics, parametersList.Count - 2, parameterCreationFunc: (Binder binder, FunctionPointerMethodSymbol owner, TypeWithAnnotations parameterType, - ParameterSyntax syntax, RefKind refKind, int ordinal, + FunctionPointerParameterSyntax syntax, RefKind refKind, int ordinal, SyntaxToken paramsKeyword, SyntaxToken thisKeyword, bool addRefReadOnlyModifier, DiagnosticBag diagnostics) => { @@ -104,10 +104,10 @@ public static ImmutableArray MakeFunctionPointer parsingFunctionPointer: true); } - private static ImmutableArray MakeParameters( + private static ImmutableArray MakeParameters( Binder binder, TOwningSymbol owner, - SeparatedSyntaxList parametersList, + SeparatedSyntaxList parametersList, out SyntaxToken arglistToken, DiagnosticBag diagnostics, bool allowRefOrOut, @@ -115,8 +115,9 @@ private static ImmutableArray MakeParameters parameterCreationFunc, + Func parameterCreationFunc, bool parsingFunctionPointer = false) + where TParameterSyntax : BaseParameterSyntax where TParameterSymbol : ParameterSymbol where TOwningSymbol : Symbol { @@ -135,10 +136,11 @@ private static ImmutableArray MakeParameters MakeParameters MakeParameters parameter.GetNonNullSyntaxNode().Location; - private static void CheckParameterModifiers( - ParameterSyntax parameter, DiagnosticBag diagnostics, bool parsingFunctionPointerParams) + private static void CheckParameterModifiers( + TParameterSyntax parameter, DiagnosticBag diagnostics, bool parsingFunctionPointerParams) where TParameterSyntax : BaseParameterSyntax { var seenThis = false; var seenRef = false; @@ -420,17 +422,18 @@ private static void CheckParameterModifiers( } } - private static void ReportParameterErrors( + private static void ReportParameterErrors( Symbol owner, - ParameterSyntax parameterSyntax, + TParameterSyntax parameterSyntax, ParameterSymbol parameter, SyntaxToken thisKeyword, SyntaxToken paramsKeyword, int firstDefault, DiagnosticBag diagnostics) + where TParameterSyntax : BaseParameterSyntax { int parameterIndex = parameter.Ordinal; - bool isDefault = parameterSyntax.Default != null; + bool isDefault = parameterSyntax is ParameterSyntax { Default: { } }; if (thisKeyword.Kind() == SyntaxKind.ThisKeyword && parameterIndex != 0) { @@ -458,7 +461,7 @@ private static void ReportParameterErrors( else if (firstDefault != -1 && parameterIndex > firstDefault && !isDefault && !parameter.IsParams) { // error CS1737: Optional parameters must appear after all required parameters - Location loc = parameterSyntax.Identifier.GetNextToken(includeZeroWidth: true).GetLocation(); //could be missing + Location loc = ((ParameterSyntax)(BaseParameterSyntax)parameterSyntax).Identifier.GetNextToken(includeZeroWidth: true).GetLocation(); //could be missing diagnostics.Add(ErrorCode.ERR_DefaultValueBeforeRequiredValue, loc); } else if (parameter.RefKind != RefKind.None && diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml index b7ecd3461119d..a965ce68616ca 100644 --- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml +++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml @@ -242,7 +242,7 @@ SyntaxToken representing the optional calling convention. - + List of the parameter types and return type of the function pointer. @@ -275,7 +275,7 @@ Function pointer calling convention syntax. - + @@ -283,7 +283,7 @@ SyntaxToken representing whether the calling convention is managed or unmanaged. - + Optional list of identifiers that will contribute to an unmanaged calling convention. @@ -317,7 +317,7 @@ Individual function pointer unmanaged calling convention. - + SyntaxToken the calling convention identifier. diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs index 77d1b868cc6db..6588ba25d71a2 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxExtensions.cs @@ -440,9 +440,9 @@ internal static void VisitRankSpecifiers(this TypeSyntax type, Action= 0; i--) + for (int i = functionPointerTypeSyntax.ParameterList.Parameters.Count - 1; i >= 0; i--) { - TypeSyntax? paramType = functionPointerTypeSyntax.Parameters[i].Type; + TypeSyntax? paramType = functionPointerTypeSyntax.ParameterList.Parameters[i].Type; Debug.Assert(paramType is object); stack.Push(paramType); } diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs index d6794e6184813..d1ce3e8c0f680 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxFacts.cs @@ -154,7 +154,8 @@ public static bool IsInTypeOnlyContext(ExpressionSyntax node) return ((RefTypeSyntax)parent).Type == node; case Parameter: - return ((ParameterSyntax)parent).Type == node; + case FunctionPointerParameter: + return ((BaseParameterSyntax)parent).Type == node; case TypeConstraint: return ((TypeConstraintSyntax)parent).Type == node; diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs index 6b3b9d57b7ca4..c072df93fee02 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs @@ -619,9 +619,10 @@ public enum SyntaxKind : ushort NullableDirectiveTrivia = 9055, FunctionPointerType = 9056, + // PROTOTYPE(func-ptr): Go through the things that use SyntaxKind.Parameter and adjust as necessary FunctionPointerParameter = 9057, FunctionPointerParameterList = 9058, - FunctionPointerCallingConventionList = 9059, + FunctionPointerCallingConvention = 9059, InitAccessorDeclaration = 9060, @@ -632,5 +633,6 @@ public enum SyntaxKind : ushort PrimaryConstructorBaseType = 9065, FunctionPointerUnmanagedCallingConventionList = 9066, + FunctionPointerUnmanagedCallingConvention = 9067, } } diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf index 2713179c8f3da..ca6a02304e7f6 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf index 9e5d2fab62c07..d5378cec8b88e 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf index f91c5995bcb3a..ff1d2404198f5 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf index 806cd832f7ce2..0f5c0b95e9b6f 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf index 0edd69e0a1abc..0d135066c13f2 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf index 7dc96d5b7e139..9225d060c4a60 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf index 8831722c236d7..5e9390070f877 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf index f65c5e887eb15..a442aa9624d3b 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf index 7f64d40e90089..0b258fff1ab9d 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf index 28df0bb4a50c9..c063f96744329 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf index fc75946164d02..d9ae8c74e0fa1 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf index fb712fca803ae..97ac55d6baf75 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf index 18892cdd82cbc..e2729a87b7cdf 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf @@ -157,6 +157,11 @@ Cannot convert &method group '{0}' to delegate type '{0}'. + + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + + The type of a local declared in a fixed statement cannot be a function pointer type. The type of a local declared in a fixed statement cannot be a function pointer type. diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs index fc6a17474a8f5..ceaf2f37c44bc 100644 --- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs +++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs @@ -63,10 +63,13 @@ private CSharpCompilation CreateCompilationWithFunctionPointersAndIl(string sour [Theory] [InlineData("", CallingConvention.Default)] - [InlineData("cdecl", CallingConvention.CDecl)] [InlineData("managed", CallingConvention.Default)] - [InlineData("thiscall", CallingConvention.ThisCall)] - [InlineData("stdcall", CallingConvention.Standard)] + [InlineData("unmanaged[Cdecl]", CallingConvention.CDecl)] + [InlineData("unmanaged[Thiscall]", CallingConvention.ThisCall)] + [InlineData("unmanaged[Stdcall]", CallingConvention.Standard)] + [InlineData("unmanaged[Fastcall]", CallingConvention.FastCall)] + // PROTOTYPE(func-ptr): Update SRM so it can decode the convention correctly + //[InlineData("unmanaged", CallingConvention.Unmanaged)] internal void CallingConventions(string conventionString, CallingConvention expectedConvention) { var verifier = CompileAndVerifyFunctionPointers($@" @@ -143,7 +146,7 @@ public void NestedFunctionPointers() var verifier = CompileAndVerifyFunctionPointers(@" public class C { - public unsafe delegate* cdecl, void> M(delegate*> param1) => throw null; + public unsafe delegate* unmanaged[Cdecl], void> M(delegate*> param1) => throw null; } public struct S { @@ -597,7 +600,7 @@ public void NestedPointerTypes() var verifier = CompileAndVerifyFunctionPointers(@" public class C { - public unsafe delegate* cdecl, void> M(delegate*>, delegate*> param) => throw null; + public unsafe delegate* unmanaged[Cdecl], void> M(delegate*>, delegate*> param) => throw null; }", symbolValidator: symbolValidator); symbolValidator(GetSourceModule(verifier)); @@ -720,7 +723,7 @@ public void FunctionPointersInProperties() public unsafe class C { public delegate* Prop1 { get; set; } - public delegate* stdcall Prop2 { get => throw null; set => throw null; } + public delegate* unmanaged[Stdcall] Prop2 { get => throw null; set => throw null; } }", symbolValidator: symbolValidator); symbolValidator(GetSourceModule(verifier)); @@ -1265,7 +1268,7 @@ public unsafe static void Main() Call(UnmanagedFunctionPointer.GetFuncPtr()); }} - public unsafe static void Call(delegate* {convention} ptr) + public unsafe static void Call(delegate* unmanaged[{char.ToUpper(convention[0]) + convention[1..]}] ptr) {{ Console.WriteLine(ptr(""Hello"", "" World"")); }} @@ -3413,9 +3416,9 @@ void M() } [Theory] - [InlineData("cdecl", "CDecl")] - [InlineData("stdcall", "Standard")] - [InlineData("thiscall", "ThisCall")] + [InlineData("unmanaged[Cdecl]", "CDecl")] + [InlineData("unmanaged[Stdcall]", "Standard")] + [InlineData("unmanaged[Thiscall]", "ThisCall")] public void AddressOf_CallingConventionMustMatch(string callingConventionKeyword, string callingConvention) { var comp = CreateCompilationWithFunctionPointers($@" @@ -6231,17 +6234,17 @@ protected virtual void M1(delegate* ptr) {} } unsafe class Derived : Base { - protected override void M1(delegate* cdecl ptr) {} - protected override delegate* cdecl M2() => throw null; + protected override void M1(delegate* unmanaged[Cdecl] ptr) {} + protected override delegate* unmanaged[Cdecl] M2() => throw null; }"); comp.VerifyDiagnostics( // (9,29): error CS0115: 'Derived.M1(delegate*)': no suitable method found to override - // protected override void M1(delegate* cdecl ptr) {} + // protected override void M1(delegate* unmanaged[Cdecl] ptr) {} Diagnostic(ErrorCode.ERR_OverrideNotExpected, "M1").WithArguments("Derived.M1(delegate*)").WithLocation(9, 29), - // (10,46): error CS0508: 'Derived.M2()': return type must be 'delegate*' to match overridden member 'Base.M2()' - // protected override delegate* cdecl M2() => throw null; - Diagnostic(ErrorCode.ERR_CantChangeReturnTypeOnOverride, "M2").WithArguments("Derived.M2()", "Base.M2()", "delegate*").WithLocation(10, 46) + // (10,57): error CS0508: 'Derived.M2()': return type must be 'delegate*' to match overridden member 'Base.M2()' + // protected override delegate* unmanaged[Cdecl] M2() => throw null; + Diagnostic(ErrorCode.ERR_CantChangeReturnTypeOnOverride, "M2").WithArguments("Derived.M2()", "Base.M2()", "delegate*").WithLocation(10, 57) ); } diff --git a/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.AllInOne.cs b/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.AllInOne.cs index 3d33e6d626ea2..2229b6f68a02c 100644 --- a/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.AllInOne.cs +++ b/src/Compilers/CSharp/Test/Semantic/Diagnostics/DiagnosticAnalyzerTests.AllInOne.cs @@ -31,7 +31,6 @@ public void DiagnosticAnalyzerAllInOne() // https://github.com/dotnet/roslyn/issues/44682 Add to all in one missingSyntaxKinds.Add(SyntaxKind.WithExpression); missingSyntaxKinds.Add(SyntaxKind.RecordDeclaration); - missingSyntaxKinds.Add(SyntaxKind.FunctionPointerType); var analyzer = new CSharpTrackingDiagnosticAnalyzer(); CreateCompilationWithMscorlib45(source).VerifyAnalyzerDiagnostics(new[] { analyzer }); diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs index 99c04a4bf0510..7680ca1cd03b3 100644 --- a/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs +++ b/src/Compilers/CSharp/Test/Semantic/Semantics/FunctionPointerTests.cs @@ -153,7 +153,7 @@ unsafe class C void M() { delegate* ptr1 = null; - delegate* cdecl ptr2 = null; + delegate* unmanaged[Cdecl] ptr2 = null; delegate* ptr3 = null; delegate* ptr4 = null; } @@ -970,22 +970,22 @@ unsafe class C { void M(delegate* param1) { - delegate* cdecl ptr1 = param1; - delegate* thiscall ptr2 = param1; - delegate* stdcall ptr3 = param1; + delegate* unmanaged[Cdecl] ptr1 = param1; + delegate* unmanaged[Thiscall] ptr2 = param1; + delegate* unmanaged[Stdcall] ptr3 = param1; } }"); comp.VerifyDiagnostics( - // (6,38): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) - // delegate* cdecl ptr1 = param1; - Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(6, 38), - // (7,41): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) - // delegate* thiscall ptr2 = param1; - Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(7, 41), - // (8,40): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) - // delegate* stdcall ptr3 = param1; - Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(8, 40) + // (6,49): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) + // delegate* unmanaged[Cdecl] ptr1 = param1; + Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(6, 49), + // (7,52): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) + // delegate* unmanaged[Thiscall] ptr2 = param1; + Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(7, 52), + // (8,51): error CS0266: Cannot implicitly convert type 'delegate*' to 'delegate*'. An explicit conversion exists (are you missing a cast?) + // delegate* unmanaged[Stdcall] ptr3 = param1; + Diagnostic(ErrorCode.ERR_NoImplicitConvCast, "param1").WithArguments("delegate*", "delegate*").WithLocation(8, 51) ); var tree = comp.SyntaxTrees[0]; @@ -1394,7 +1394,7 @@ public static void M() SubstitutedStatic(ptr1); delegate* ptr2 = null; delegate* ptr3 = null; - delegate* cdecl ptr4 = null; + delegate* unmanaged[Cdecl] ptr4 = null; SubstitutedStatic2(ptr1, ptr1); SubstitutedStatic2(ptr1, ptr2); SubstitutedStatic2(ptr1, ptr3); @@ -1403,7 +1403,7 @@ public static void M() delegate* ptr5 = null; delegate* ptr6 = null; delegate* ptr7 = null; - delegate* cdecl ptr8 = null; + delegate* unmanaged[Cdecl] ptr8 = null; SubstitutedStatic2(ptr5, ptr5); SubstitutedStatic2(ptr5, ptr6); SubstitutedStatic2(ptr5, ptr7); @@ -1546,7 +1546,7 @@ public static void M() delegate*[] ptr1 = null; delegate*[] ptr2 = null; delegate*[] ptr3 = null; - delegate* cdecl[] ptr4 = null; + delegate* unmanaged[Cdecl][] ptr4 = null; SubstitutedStatic2(ptr1, ptr2); SubstitutedStatic2(ptr1, ptr3); SubstitutedStatic2(ptr1, ptr4); @@ -1554,7 +1554,7 @@ public static void M() delegate*[] ptr5 = null; delegate*[] ptr6 = null; delegate*[] ptr7 = null; - delegate* cdecl[] ptr8 = null; + delegate* unmanaged[Cdecl][] ptr8 = null; SubstitutedStatic2(ptr5, ptr6); SubstitutedStatic2(ptr5, ptr7); SubstitutedStatic2(ptr5, ptr8); @@ -1620,7 +1620,7 @@ public static void M() delegate*[] ptr1 = null; delegate*[] ptr2 = null; delegate*[] ptr3 = null; - delegate* cdecl[] ptr4 = null; + delegate* unmanaged[Cdecl][] ptr4 = null; var arr1 = new[] { ptr1, ptr2 }; var arr2 = new[] { ptr1, ptr3 }; var arr3 = new[] { ptr1, ptr4 }; @@ -1628,7 +1628,7 @@ public static void M() delegate*[] ptr5 = null; delegate*[] ptr6 = null; delegate*[] ptr7 = null; - delegate* cdecl[] ptr8 = null; + delegate* unmanaged[Cdecl][] ptr8 = null; var arr4 = new[] { ptr5, ptr6 }; var arr5 = new[] { ptr5, ptr7 }; var arr6 = new[] { ptr5, ptr8 }; @@ -1688,7 +1688,7 @@ public static void M(bool b) delegate*[] ptr1 = null; delegate*[] ptr2 = null; delegate*[] ptr3 = null; - delegate* cdecl[] ptr4 = null; + delegate* unmanaged[Cdecl][] ptr4 = null; _ = b ? ptr1 : ptr2; _ = b ? ptr1 : ptr3; _ = b ? ptr1 : ptr4; @@ -1696,7 +1696,7 @@ public static void M(bool b) delegate*[] ptr5 = null; delegate*[] ptr6 = null; delegate*[] ptr7 = null; - delegate* cdecl[] ptr8 = null; + delegate* unmanaged[Cdecl][] ptr8 = null; _ = b ? ptr5 : ptr6; _ = b ? ptr5 : ptr7; _ = b ? ptr5 : ptr8; diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs index d36ac3851109d..2bff51c27e8b6 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs @@ -223,9 +223,11 @@ unsafe void M( [InlineData("", CallingConvention.Default)] [InlineData("managed", CallingConvention.Default)] - [InlineData("cdecl", CallingConvention.CDecl)] - [InlineData("stdcall", CallingConvention.Standard)] - [InlineData("thiscall", CallingConvention.ThisCall)] + [InlineData("unmanaged[Cdecl]", CallingConvention.CDecl)] + [InlineData("unmanaged[Stdcall]", CallingConvention.Standard)] + [InlineData("unmanaged[Thiscall]", CallingConvention.ThisCall)] + [InlineData("unmanaged[Fastcall]", CallingConvention.FastCall)] + [InlineData("unmanaged", CallingConvention.Unmanaged, Skip = "PROTOTYPE(func-ptr): Update SRM to understand the new bit")] [Theory] internal void ValidCallingConventions(string convention, CallingConvention expectedConvention) { @@ -260,12 +262,12 @@ public void InvalidCallingConventions() var comp = CreateFunctionPointerCompilation(@" class C { - public unsafe void M(delegate* invalid p) {} + public unsafe void M(delegate* unmanaged[invalid] p) {} }"); comp.VerifyDiagnostics( - // (4,36): error CS8807: 'invalid' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - // public void M(delegate* invalid p) {} - Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "invalid").WithArguments("invalid").WithLocation(4, 36)); + // (4,36): error CS8807: 'invalid' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + // public unsafe void M(delegate* unmanaged[invalid] p) {} + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "unmanaged[invalid]").WithArguments("invalid").WithLocation(4, 36)); var c = comp.GetTypeByMetadataName("C"); var m = c.GetMethod("M"); @@ -279,7 +281,7 @@ public unsafe void M(delegate* invalid p) {} FunctionPointerUtilities.VerifyFunctionPointerSemanticInfo(model, syntaxTree.GetRoot().DescendantNodes().OfType().Single(), - expectedSyntax: "delegate* invalid", + expectedSyntax: "delegate* unmanaged[invalid]", expectedType: "delegate*", expectedSymbol: "delegate*"); } @@ -756,8 +758,8 @@ public void Equality_CallingConventionNotEqual() var comp = CreateFunctionPointerCompilation(@" class C { - unsafe void M(delegate* cdecl p1, - delegate* thiscall p2) {} + unsafe void M(delegate* unmanaged[Cdecl] p1, + delegate* unmanaged[Thiscall] p2) {} }"); comp.VerifyDiagnostics(); @@ -1088,7 +1090,7 @@ unsafe void M() var misplacedDeclaration = ((ArrayTypeSyntax)functionPointerTypeSyntax - .Parameters.Single().Type!) + .ParameterList.Parameters.Single().Type!) .RankSpecifiers.Single() .Sizes.Single(); @@ -1198,7 +1200,7 @@ unsafe void M() Assert.Equal("delegate*", typeInfo.Type.ToTestDisplayString()); Assert.True(((IFunctionPointerTypeSymbol)typeInfo.Type!).Signature.ReturnType.IsErrorType()); - var nestedTypeInfo = model.GetTypeInfo(functionPointerTypeSyntax.Parameters.Single().Type!); + var nestedTypeInfo = model.GetTypeInfo(functionPointerTypeSyntax.ParameterList.Parameters.Single().Type!); Assert.Equal("C.D", nestedTypeInfo.Type!.ToTestDisplayString()); Assert.False(nestedTypeInfo.Type!.IsErrorType()); diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs index e942cbbab3a92..6aeb1b9809f28 100644 --- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs +++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs @@ -50,7 +50,7 @@ private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSy => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(InternalSyntaxFactory.Token(SyntaxKind.OpenBracketToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.CloseBracketToken)); private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() - => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConvention(InternalSyntaxFactory.Identifier("CallingConvention")); + => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConvention(InternalSyntaxFactory.Identifier("Name")); private static Syntax.InternalSyntax.NullableTypeSyntax GenerateNullableType() => InternalSyntaxFactory.NullableType(GenerateIdentifierName(), InternalSyntaxFactory.Token(SyntaxKind.QuestionToken)); @@ -811,7 +811,7 @@ public void TestFunctionPointerTypeFactoryAndProperties() Assert.Equal(SyntaxKind.DelegateKeyword, node.DelegateKeyword.Kind); Assert.Equal(SyntaxKind.AsteriskToken, node.AsteriskToken.Kind); Assert.Null(node.CallingConvention); - Assert.NotNull(node.Parameters); + Assert.NotNull(node.ParameterList); AttachAndCheckDiagnostics(node); } @@ -834,7 +834,7 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() var node = GenerateFunctionPointerCallingConvention(); Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind); - Assert.Null(node.UnmanagedCallingConventionSpecifiers); + Assert.Null(node.UnmanagedCallingConventionList); AttachAndCheckDiagnostics(node); } @@ -856,7 +856,7 @@ public void TestFunctionPointerUnmanagedCallingConventionFactoryAndProperties() { var node = GenerateFunctionPointerUnmanagedCallingConvention(); - Assert.Equal(SyntaxKind.IdentifierToken, node.CallingConvention.Kind); + Assert.Equal(SyntaxKind.IdentifierToken, node.Name.Kind); AttachAndCheckDiagnostics(node); } @@ -9674,7 +9674,7 @@ private static FunctionPointerUnmanagedCallingConventionSyntaxList GenerateFunct => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); private static FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() - => SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("CallingConvention")); + => SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("Name")); private static NullableTypeSyntax GenerateNullableType() => SyntaxFactory.NullableType(GenerateIdentifierName(), SyntaxFactory.Token(SyntaxKind.QuestionToken)); @@ -10435,8 +10435,8 @@ public void TestFunctionPointerTypeFactoryAndProperties() Assert.Equal(SyntaxKind.DelegateKeyword, node.DelegateKeyword.Kind()); Assert.Equal(SyntaxKind.AsteriskToken, node.AsteriskToken.Kind()); Assert.Null(node.CallingConvention); - Assert.NotNull(node.Parameters); - var newNode = node.WithDelegateKeyword(node.DelegateKeyword).WithAsteriskToken(node.AsteriskToken).WithCallingConvention(node.CallingConvention).WithParameters(node.Parameters); + Assert.NotNull(node.ParameterList); + var newNode = node.WithDelegateKeyword(node.DelegateKeyword).WithAsteriskToken(node.AsteriskToken).WithCallingConvention(node.CallingConvention).WithParameterList(node.ParameterList); Assert.Equal(node, newNode); } @@ -10458,8 +10458,8 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() var node = GenerateFunctionPointerCallingConvention(); Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind()); - Assert.Null(node.UnmanagedCallingConventionSpecifiers); - var newNode = node.WithManagedSpecifier(node.ManagedSpecifier).WithUnmanagedCallingConventionSpecifiers(node.UnmanagedCallingConventionSpecifiers); + Assert.Null(node.UnmanagedCallingConventionList); + var newNode = node.WithManagedSpecifier(node.ManagedSpecifier).WithUnmanagedCallingConventionList(node.UnmanagedCallingConventionList); Assert.Equal(node, newNode); } @@ -10480,8 +10480,8 @@ public void TestFunctionPointerUnmanagedCallingConventionFactoryAndProperties() { var node = GenerateFunctionPointerUnmanagedCallingConvention(); - Assert.Equal(SyntaxKind.IdentifierToken, node.CallingConvention.Kind()); - var newNode = node.WithCallingConvention(node.CallingConvention); + Assert.Equal(SyntaxKind.IdentifierToken, node.Name.Kind()); + var newNode = node.WithName(node.Name); Assert.Equal(node, newNode); } diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs index 39d68fc7be604..fb962a9d36862 100644 --- a/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs +++ b/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs @@ -27,34 +27,159 @@ public void SimpleFunctionPointerTest() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Goo"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + } + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Theory] + [InlineData("Cdecl")] + [InlineData("Stdcall")] + [InlineData("Thiscall")] + [InlineData("Fastcall")] + [InlineData("invalidcallingconvention")] // This is a semantic error, not a syntax error + public void UnmanagedCallingConventionSpecifiers(string conventionString) + { + UsingStatement($"delegate* unmanaged[{conventionString}] ptr;", options: TestOptions.RegularPreview); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IdentifierToken, "Goo"); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, conventionString); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Goo"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void KeywordInCallingConventionList() + { + UsingStatement("delegate* unmanaged[void] ptr;", options: TestOptions.RegularPreview, + // (1,21): error CS1041: Identifier expected; 'void' is a keyword + // delegate* unmanaged[void] ptr; + Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "void").WithArguments("", "void").WithLocation(1, 21), + // (1,21): error CS1003: Syntax error, ',' expected + // delegate* unmanaged[void] ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments(",", "void").WithLocation(1, 21) + ); + + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + M(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + M(SyntaxKind.IdentifierToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -67,16 +192,11 @@ public void SimpleFunctionPointerTest() } [Theory] - [InlineData("cdecl")] [InlineData("managed")] - [InlineData("stdcall")] - [InlineData("thiscall")] [InlineData("unmanaged")] - [InlineData("invalidcallingconvention")] // This is a semantic error, not a syntax error - [InlineData("void")] // This is a semantic error, not a syntax error - public void CallingConventions(string conventionString) + public void NoUnmanagedSpecifiers(string convention) { - UsingStatement($"delegate* {conventionString} ptr;", options: TestOptions.RegularPreview); + UsingStatement($"delegate* {convention} ptr;", options: TestOptions.RegularPreview); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -85,35 +205,74 @@ public void CallingConventions(string conventionString) { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(conventionString == "void" ? SyntaxKind.VoidKeyword : SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(convention == "managed" ? SyntaxKind.ManagedKeyword : SyntaxKind.UnmanagedKeyword); + } + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void ManagedWithUnmanagedSpecifiers() + { + UsingStatement("delegate* managed[Cdecl] ptr;", options: TestOptions.RegularPreview, + // (1,18): error CS9500: 'managed' calling convention cannot be combined with unmanaged calling convention specifiers. + // delegate* managed[Cdecl] ptr; + Diagnostic(ErrorCode.ERR_CannotSpecifyManagedWithUnmanagedSpecifiers, "[Cdecl]").WithLocation(1, 18) + ); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.ManagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IdentifierToken, "Goo"); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -126,12 +285,13 @@ public void CallingConventions(string conventionString) } [Fact] - public void LangVersion8() + public void InvalidConventionWithUnmanagedSpecifiers() { - UsingStatement("delegate* cdecl ptr;", options: TestOptions.Regular8, - // (1,1): error CS8652: The feature 'function pointers' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. - // delegate* cdecl ptr; - Diagnostic(ErrorCode.ERR_FeatureInPreview, "delegate* cdecl").WithArguments("function pointers").WithLocation(1, 1)); + UsingStatement("delegate* invalid[Cdecl] ptr;", options: TestOptions.RegularPreview, + // (1,11): error CS1003: Syntax error, 'unmanaged' expected + // delegate* invalid[Cdecl] ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "invalid").WithArguments("unmanaged", "").WithLocation(1, 11) + ); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -140,35 +300,83 @@ public void LangVersion8() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + M(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "Goo"); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void EmptyUnmanagedSpecifierBraces() + { + UsingStatement("delegate* unmanaged[] ptr;", options: TestOptions.RegularPreview, + // (1,21): error CS1001: Identifier expected + // delegate* unmanaged[] ptr; + Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(1, 21) + ); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.OpenBracketToken); + M(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + M(SyntaxKind.IdentifierToken); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } } N(SyntaxKind.VariableDeclarator); { @@ -181,10 +389,9 @@ public void LangVersion8() } [Fact] - public void VoidsAsType() + public void MultipleUnmanagedSpecifiers() { - // Void isn't allowed in anything but the return type, but that's a semantic error, not a syntax error - UsingStatement("delegate* ptr;", options: TestOptions.RegularPreview); + UsingStatement("delegate* unmanaged[Cdecl, Thiscall, Stdcall, Fastcall, Vectorcall, SuppressGCTransition] ptr;", options: TestOptions.RegularPreview); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -193,34 +400,175 @@ public void VoidsAsType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Thiscall"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Stdcall"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Fastcall"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Vectorcall"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "SuppressGCTransition"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void LangVersion8() + { + UsingStatement("delegate* unmanaged[cdecl] ptr;", options: TestOptions.Regular8, + // (1,1): error CS8652: The feature 'function pointers' is currently in Preview and *unsupported*. To use Preview features, use the 'preview' language version. + // delegate* unmanaged[cdecl] ptr; + Diagnostic(ErrorCode.ERR_FeatureInPreview, "delegate* unmanaged[cdecl]").WithArguments("function pointers").WithLocation(1, 1)); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Goo"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void VoidsAsType() + { + // Void isn't allowed in anything but the return type, but that's a semantic error, not a syntax error + UsingStatement("delegate* ptr;", options: TestOptions.RegularPreview); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } } N(SyntaxKind.VariableDeclarator); { @@ -235,7 +583,7 @@ public void VoidsAsType() [Fact] public void NestedFunctionPointers() { - UsingStatement("delegate*, delegate* managed> ptr;", options: TestOptions.RegularPreview); + UsingStatement("delegate*, delegate* managed> ptr;", options: TestOptions.RegularPreview); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -244,70 +592,89 @@ public void NestedFunctionPointers() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.FunctionPointerType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.DelegateKeyword); - N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerType); { - N(SyntaxKind.PointerType); + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - N(SyntaxKind.AsteriskToken); } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PointerType); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.AsteriskToken); + } } - N(SyntaxKind.AsteriskToken); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.AsteriskToken); + } + } + N(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.FunctionPointerType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.DelegateKeyword); - N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "managed"); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerType); { - N(SyntaxKind.PointerType); + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.ManagedKeyword); + } + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.AsteriskToken); + } } - N(SyntaxKind.AsteriskToken); + N(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -333,25 +700,26 @@ public void PointerToAFunctionPointer() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "Goo"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Goo"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.AsteriskToken); } @@ -377,52 +745,51 @@ public void RefModifiers() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "Goo"); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Goo"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.InKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "Bar"); + N(SyntaxKind.InKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Bar"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.OutKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "Baz"); + N(SyntaxKind.OutKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Baz"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.ReadOnlyKeyword); - N(SyntaxKind.PointerType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.ReadOnlyKeyword); + N(SyntaxKind.PointerType); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.AsteriskToken); } - N(SyntaxKind.AsteriskToken); } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -455,16 +822,18 @@ public void Unterminated_01() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -497,17 +866,19 @@ public void Unterminated_02() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - M(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.RefKeyword); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -537,17 +908,19 @@ public void Unterminated_03() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "bar"); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "bar"); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -580,26 +953,81 @@ public void Unterminated_04() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "bar"); + } + } + N(SyntaxKind.CommaToken); + M(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "bar"); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.CommaToken); - M(SyntaxKind.Parameter); + } + M(SyntaxKind.VariableDeclarator); + { + M(SyntaxKind.IdentifierToken); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void Unterminated_05() + { + UsingStatement("delegate* unmanaged[ptr];", options: TestOptions.RegularPreview, + // (1,25): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[ptr]; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 25), + // (1,25): error CS1001: Identifier expected + // delegate* unmanaged[ptr]; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 25)); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -612,12 +1040,120 @@ public void Unterminated_04() } [Fact] - public void Unterminated_05() + public void Unterminated_06() + { + UsingStatement("delegate* unmanaged[cdecl] ;", options: TestOptions.RegularPreview, + // (1,28): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[cdecl] ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 28), + // (1,28): error CS1001: Identifier expected + // delegate* unmanaged[cdecl] ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 28)); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.VariableDeclarator); + { + M(SyntaxKind.IdentifierToken); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void Unterminated_07() + { + UsingStatement("delegate* unmanaged[cdecl] ptr;", options: TestOptions.RegularPreview, + // (1,28): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[cdecl] ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "ptr").WithArguments("<", "").WithLocation(1, 28)); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void Unterminated_08() { - UsingStatement("delegate* ptr;", options: TestOptions.RegularPreview, + UsingStatement("delegate* ;", options: TestOptions.RegularPreview, // (1,11): error CS1003: Syntax error, '<' expected - // delegate* ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "ptr").WithArguments("<", "").WithLocation(1, 11)); + // delegate* ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 11), + // (1,11): error CS1001: Identifier expected + // delegate* ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 11)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -626,18 +1162,96 @@ public void Unterminated_05() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.VariableDeclarator); + { + M(SyntaxKind.IdentifierToken); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + + [Fact] + public void Unterminated_09() + { + UsingStatement("delegate* unmanaged.Name[Dotted] ptr;", options: TestOptions.RegularPreview, + // (1,9): error CS1514: { expected + // delegate* unmanaged.Name[Dotted] ptr; + Diagnostic(ErrorCode.ERR_LbraceExpected, "*").WithLocation(1, 9), + // (1,34): error CS1525: Invalid expression term 'void' + // delegate* unmanaged.Name[Dotted] ptr; + Diagnostic(ErrorCode.ERR_InvalidExprTerm, "void").WithArguments("void").WithLocation(1, 34)); + // This is ambiguous. However, the parser attempts to do better error recovery when the start + // of a statement is MustBeType followed by a `.`, which while better for the general case, results + // in this not being parsed as a function pointer. + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.GreaterThanExpression); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.MultiplyExpression); { - M(SyntaxKind.IdentifierName); + N(SyntaxKind.AnonymousMethodExpression); + { + N(SyntaxKind.DelegateKeyword); + M(SyntaxKind.Block); + { + M(SyntaxKind.OpenBraceToken); + M(SyntaxKind.CloseBraceToken); + } + } + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.ElementAccessExpression); { - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "unmanaged"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Name"); + } + } + N(SyntaxKind.BracketedArgumentList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Dotted"); + } + } + N(SyntaxKind.CloseBracketToken); + } } - M(SyntaxKind.IdentifierToken); } - M(SyntaxKind.GreaterThanToken); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - N(SyntaxKind.VariableDeclarator); + N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.IdentifierName); { N(SyntaxKind.IdentifierToken, "ptr"); } @@ -648,15 +1262,21 @@ public void Unterminated_05() } [Fact] - public void Unterminated_06() + public void Unterminated_10() { - UsingStatement("delegate* cdecl ;", options: TestOptions.RegularPreview, - // (1,17): error CS1003: Syntax error, '<' expected - // delegate* cdecl ; - Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 17), - // (1,17): error CS1001: Identifier expected - // delegate* cdecl ; - Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 17)); + UsingStatement("delegate*( ;", options: TestOptions.RegularPreview, + // (1,10): error CS1003: Syntax error, '<' expected + // delegate*( ; + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("<", "(").WithLocation(1, 10), + // (1,12): error CS1031: Type expected + // delegate*( ; + Diagnostic(ErrorCode.ERR_TypeExpected, ";").WithLocation(1, 12), + // (1,12): error CS1003: Syntax error, '>' expected + // delegate*( ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments(">", ";").WithLocation(1, 12), + // (1,12): error CS1001: Identifier expected + // delegate*( ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 12)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -665,17 +1285,18 @@ public void Unterminated_06() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -688,12 +1309,18 @@ public void Unterminated_06() } [Fact] - public void Unterminated_07() + public void Unterminated_11() { - UsingStatement("delegate* cdecl ptr;", options: TestOptions.RegularPreview, - // (1,17): error CS1003: Syntax error, '<' expected - // delegate* cdecl ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "ptr").WithArguments("<", "").WithLocation(1, 17)); + UsingStatement("delegate* @cdecl>", options: TestOptions.RegularPreview, + // (1,11): error CS1003: Syntax error, '<' expected + // delegate* @cdecl> + Diagnostic(ErrorCode.ERR_SyntaxError, "@cdecl").WithArguments("<", "").WithLocation(1, 11), + // (1,17): error CS1003: Syntax error, ',' expected + // delegate* @cdecl> + Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments(",", ">").WithLocation(1, 17), + // (1,18): error CS1002: ; expected + // delegate* @cdecl> + Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 18)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -702,38 +1329,46 @@ public void Unterminated_07() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { - N(SyntaxKind.IdentifierToken, "ptr"); + N(SyntaxKind.IdentifierToken, "@cdecl"); } } - N(SyntaxKind.SemicolonToken); + M(SyntaxKind.SemicolonToken); } EOF(); } [Fact] - public void Unterminated_08() + public void Unterminated_12() { - UsingStatement("delegate* ;", options: TestOptions.RegularPreview, - // (1,11): error CS1003: Syntax error, '<' expected - // delegate* ; - Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 11), - // (1,11): error CS1001: Identifier expected - // delegate* ; - Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 11)); + UsingStatement("delegate* unmanaged[ ;", options: TestOptions.RegularPreview, + // (1,22): error CS1001: Identifier expected + // delegate* unmanaged[ ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 22), + // (1,22): error CS1003: Syntax error, ']' expected + // delegate* unmanaged[ ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("]", ";").WithLocation(1, 22), + // (1,22): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[ ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 22), + // (1,22): error CS1001: Identifier expected + // delegate* unmanaged[ ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 22) + ); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -742,16 +1377,31 @@ public void Unterminated_08() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - M(SyntaxKind.IdentifierName); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.OpenBracketToken); + M(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -764,15 +1414,19 @@ public void Unterminated_08() } [Fact] - public void Unterminated_09() + public void Unterminated_13() { - UsingStatement("delegate* Dotted.Name ptr;", options: TestOptions.RegularPreview, - // (1,11): error CS1003: Syntax error, '<' expected - // delegate* Dotted.Name ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "Dotted").WithArguments("<", "").WithLocation(1, 11), - // (1,17): error CS1003: Syntax error, ',' expected - // delegate* Dotted.Name ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, ".").WithArguments(",", ".").WithLocation(1, 17)); + UsingStatement("delegate* unmanaged[Cdecl ;", options: TestOptions.RegularPreview, + // (1,27): error CS1003: Syntax error, ']' expected + // delegate* unmanaged[Cdecl ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("]", ";").WithLocation(1, 27), + // (1,27): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[Cdecl ; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments("<", "").WithLocation(1, 27), + // (1,27): error CS1001: Identifier expected + // delegate* unmanaged[Cdecl ; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 27) + ); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -781,61 +1435,31 @@ public void Unterminated_09() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - M(SyntaxKind.IdentifierName); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + M(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - M(SyntaxKind.GreaterThanToken); - } - N(SyntaxKind.VariableDeclarator); - { - N(SyntaxKind.IdentifierToken, "Dotted"); - } - } - N(SyntaxKind.SemicolonToken); - } - EOF(); - } - - [Fact] - public void Unterminated_10() - { - UsingStatement("delegate*( ;", options: TestOptions.RegularPreview, - // (1,10): error CS1003: Syntax error, '<' expected - // delegate*( ; - Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("<", "(").WithLocation(1, 10), - // (1,12): error CS1031: Type expected - // delegate*( ; - Diagnostic(ErrorCode.ERR_TypeExpected, ";").WithLocation(1, 12), - // (1,12): error CS1003: Syntax error, '>' expected - // delegate*( ; - Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments(">", ";").WithLocation(1, 12), - // (1,12): error CS1001: Identifier expected - // delegate*( ; - Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 12)); - N(SyntaxKind.LocalDeclarationStatement); - { - N(SyntaxKind.VariableDeclaration); - { - N(SyntaxKind.FunctionPointerType); - { - N(SyntaxKind.DelegateKeyword); - N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -848,18 +1472,25 @@ public void Unterminated_10() } [Fact] - public void Unterminated_11() + public void Unterminated_14() { - UsingStatement("delegate* @cdecl>", options: TestOptions.RegularPreview, - // (1,11): error CS1003: Syntax error, '<' expected - // delegate* @cdecl> - Diagnostic(ErrorCode.ERR_SyntaxError, "@cdecl").WithArguments("<", "").WithLocation(1, 11), - // (1,17): error CS1003: Syntax error, ',' expected - // delegate* @cdecl> - Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments(",", ">").WithLocation(1, 17), - // (1,18): error CS1002: ; expected - // delegate* @cdecl> - Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 18)); + UsingStatement("delegate* unmanaged[Cdecl,", options: TestOptions.RegularPreview, + // (1,27): error CS1001: Identifier expected + // delegate* unmanaged[Cdecl, + Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(1, 27), + // (1,27): error CS1003: Syntax error, ']' expected + // delegate* unmanaged[Cdecl, + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]", "").WithLocation(1, 27), + // (1,27): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[Cdecl, + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("<", "").WithLocation(1, 27), + // (1,27): error CS1001: Identifier expected + // delegate* unmanaged[Cdecl, + Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(1, 27), + // (1,27): error CS1002: ; expected + // delegate* unmanaged[Cdecl, + Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 27) + ); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -868,20 +1499,40 @@ public void Unterminated_11() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + N(SyntaxKind.CommaToken); + M(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.VariableDeclarator); + M(SyntaxKind.VariableDeclarator); { - N(SyntaxKind.IdentifierToken, "@cdecl"); + M(SyntaxKind.IdentifierToken); } } M(SyntaxKind.SemicolonToken); @@ -904,16 +1555,18 @@ public void NoParamOrReturnTypes() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -949,25 +1602,26 @@ public void UsingParensInsteadOfAngles() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + M(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -985,7 +1639,7 @@ public void MethodTypes() UsingTree(@" class C { - public delegate* M(delegate* param1, delegate* cdecl param2) {} + public delegate* M(delegate* param1, delegate* unmanaged[cdecl] param2) {} }", options: TestOptions.RegularPreview); N(SyntaxKind.CompilationUnit); @@ -1002,25 +1656,26 @@ class C { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "M"); N(SyntaxKind.ParameterList); @@ -1032,25 +1687,26 @@ class C { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "C"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "param1"); } @@ -1061,17 +1717,31 @@ class C { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IdentifierToken, "D"); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } + } + N(SyntaxKind.GreaterThanToken); + } } N(SyntaxKind.IdentifierToken, "param2"); } @@ -1093,7 +1763,7 @@ class C [Fact] public void HardCast() { - UsingExpression("(delegate* thiscall)ptr", options: TestOptions.RegularPreview); + UsingExpression("(delegate* unmanaged[thiscall])ptr", options: TestOptions.RegularPreview); N(SyntaxKind.CastExpression); { N(SyntaxKind.OpenParenToken); @@ -1101,26 +1771,39 @@ public void HardCast() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "thiscall"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "C"); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } + } + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.CloseParenToken); N(SyntaxKind.IdentifierName); @@ -1134,7 +1817,7 @@ public void HardCast() [Fact] public void AsCast() { - UsingExpression("ptr as delegate* stdcall", options: TestOptions.RegularPreview); + UsingExpression("ptr as delegate* unmanaged[stdcall]", options: TestOptions.RegularPreview); N(SyntaxKind.AsExpression); { N(SyntaxKind.IdentifierName); @@ -1146,26 +1829,39 @@ public void AsCast() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "stdcall"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } } EOF(); @@ -1187,25 +1883,26 @@ public void TupleType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "i1"); } @@ -1216,26 +1913,30 @@ public void TupleType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.IdentifierName); - { - N(SyntaxKind.IdentifierToken, "C"); - } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.ManagedKeyword); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "D"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "i2"); } @@ -1253,7 +1954,7 @@ public void TupleType() [Fact] public void GenericArguments() { - UsingExpression("new M, delegate*>()", options: TestOptions.RegularPreview); + UsingExpression("new M, delegate*>()", options: TestOptions.RegularPreview); N(SyntaxKind.ObjectCreationExpression); { N(SyntaxKind.NewKeyword); @@ -1267,42 +1968,57 @@ public void GenericArguments() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "thiscall"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } } N(SyntaxKind.CommaToken); N(SyntaxKind.FunctionPointerType); { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "C"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "D"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.GreaterThanToken); } @@ -1319,7 +2035,7 @@ public void GenericArguments() [Fact] public void TypeOf() { - UsingExpression("typeof(delegate* cdecl)", options: TestOptions.RegularPreview); + UsingExpression("typeof(delegate* unmanaged[cdecl])", options: TestOptions.RegularPreview); N(SyntaxKind.TypeOfExpression); { N(SyntaxKind.TypeOfKeyword); @@ -1328,29 +2044,42 @@ public void TypeOf() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.ReadOnlyKeyword); - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "D"); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.ReadOnlyKeyword); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } + } + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.CloseParenToken); } @@ -1371,17 +2100,19 @@ public void ArrayType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "C"); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.ArrayRankSpecifier); { @@ -1409,7 +2140,7 @@ public void DelegateTypes() UsingNode(@" class C { - delegate delegate* cdecl M(delegate* p); + delegate delegate* unmanaged[cdecl] M(delegate* p); }", options: TestOptions.RegularPreview); N(SyntaxKind.CompilationUnit); @@ -1426,17 +2157,31 @@ class C { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); } - M(SyntaxKind.IdentifierToken); } - N(SyntaxKind.GreaterThanToken); + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } } N(SyntaxKind.IdentifierToken, "M"); N(SyntaxKind.ParameterList); @@ -1448,26 +2193,27 @@ class C { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.RefKeyword); - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "C"); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "D"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "p"); } @@ -1497,16 +2243,18 @@ public void LambdaParameterType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "p1"); } @@ -1565,16 +2313,18 @@ public void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -1589,16 +2339,18 @@ public void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "L2"); N(SyntaxKind.ParameterList); @@ -1620,16 +2372,18 @@ public void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -1662,16 +2416,18 @@ public void IsExpression() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } } EOF(); @@ -1694,16 +2450,18 @@ public void IsNamedExpression() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.SingleVariableDesignation); { @@ -1746,16 +2504,18 @@ public void SwitchStatementCase() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.PropertyPatternClause); { @@ -1778,16 +2538,18 @@ public void SwitchStatementCase() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.PositionalPatternClause); { @@ -1857,16 +2619,18 @@ public void SwitchExpressions() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.DiscardDesignation); { @@ -1888,16 +2652,18 @@ public void SwitchExpressions() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.PositionalPatternClause); { @@ -1957,16 +2723,18 @@ public void UsingStatementType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2012,16 +2780,18 @@ public void UsingDeclarationType() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2063,16 +2833,18 @@ public void FixedStatement() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2113,16 +2885,18 @@ public void ForEachVariable() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.IdentifierToken, "ptr"); N(SyntaxKind.InKeyword); @@ -2154,16 +2928,18 @@ public void ForVariable() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2202,16 +2978,18 @@ public void SizeOf() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.CloseParenToken); } @@ -2236,34 +3014,34 @@ public void SpecifiedParameterNamesAndDefaults() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.StringKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2296,16 +3074,18 @@ public void MissingListStart_01() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2320,16 +3100,16 @@ public void MissingListStart_01() [Fact] public void MissingListStart_02() { - UsingStatement("delegate* cdecl void> ptr;", options: TestOptions.RegularPreview, - // (1,17): error CS1003: Syntax error, '<' expected - // delegate* cdecl void> ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments("<", "").WithLocation(1, 17), - // (1,17): error CS1001: Identifier expected - // delegate* cdecl void> ptr; - Diagnostic(ErrorCode.ERR_IdentifierExpected, "void").WithLocation(1, 17), - // (1,17): error CS1003: Syntax error, ',' expected - // delegate* cdecl void> ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments(",", "void").WithLocation(1, 17)); + UsingStatement("delegate* unmanaged[cdecl] void> ptr;", options: TestOptions.RegularPreview, + // (1,28): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[cdecl] void> ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments("<", "").WithLocation(1, 28), + // (1,28): error CS1001: Identifier expected + // delegate* unmanaged[cdecl] void> ptr; + Diagnostic(ErrorCode.ERR_IdentifierExpected, "void").WithLocation(1, 28), + // (1,28): error CS1003: Syntax error, ',' expected + // delegate* unmanaged[cdecl] void> ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments(",", "void").WithLocation(1, 28)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -2338,17 +3118,31 @@ public void MissingListStart_02() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2375,16 +3169,18 @@ public void MissingListStart_03() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2396,6 +3192,52 @@ public void MissingListStart_03() EOF(); } + [Fact] + public void MissingListStart_04() + { + UsingStatement("delegate* unmanaged Cdecl] ptr;", options: TestOptions.RegularPreview, + // (1,21): error CS1003: Syntax error, '<' expected + // delegate* unmanaged Cdecl] ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "Cdecl").WithArguments("<", "").WithLocation(1, 21), + // (1,26): error CS1003: Syntax error, ',' expected + // delegate* unmanaged Cdecl] ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "]").WithArguments(",", "]").WithLocation(1, 26) + ); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + } + M(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + [Fact] public void ManyInvalidModifiers() { @@ -2408,22 +3250,24 @@ public void ManyInvalidModifiers() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.ThisKeyword); - N(SyntaxKind.ParamsKeyword); - N(SyntaxKind.ReadOnlyKeyword); - N(SyntaxKind.RefKeyword); - N(SyntaxKind.RefKeyword); - N(SyntaxKind.ThisKeyword); - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.ThisKeyword); + N(SyntaxKind.ParamsKeyword); + N(SyntaxKind.ReadOnlyKeyword); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.RefKeyword); + N(SyntaxKind.ThisKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2472,25 +3316,26 @@ async void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "async"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "async"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "async"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "async"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2544,25 +3389,26 @@ void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "async"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "async"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "async"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "async"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2623,25 +3469,26 @@ async void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "await"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "await"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "await"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "await"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2694,25 +3541,26 @@ void M() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "await"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "await"); + } } - M(SyntaxKind.IdentifierToken); - } - N(SyntaxKind.CommaToken); - N(SyntaxKind.Parameter); - { - N(SyntaxKind.IdentifierName); + N(SyntaxKind.CommaToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.IdentifierToken, "await"); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "await"); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.VariableDeclarator); { @@ -2751,17 +3599,18 @@ public void IncompleteAtEndOfFile() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.EndOfFileToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2774,18 +3623,18 @@ public void IncompleteAtEndOfFile() } [Fact] - public void IncompleteAtEndOfFileWithIdentifier() + public void IncompleteAtEndOfFileWithCallingConvention() { - UsingStatement("delegate* cdecl", options: TestOptions.RegularPreview, - // (1,11): error CS1003: Syntax error, '<' expected - // delegate* cdecl - Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("<", "").WithLocation(1, 16), - // (1,16): error CS1001: Identifier expected - // delegate* cdecl - Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(1, 16), - // (1,16): error CS1002: ; expected - // delegate* cdecl - Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 16)); + UsingStatement("delegate* unmanaged[cdecl]", options: TestOptions.RegularPreview, + // (1,27): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[cdecl] + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("<", "").WithLocation(1, 27), + // (1,27): error CS1001: Identifier expected + // delegate* unmanaged[cdecl] + Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(1, 27), + // (1,27): error CS1002: ; expected + // delegate* unmanaged[cdecl] + Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 27)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -2794,17 +3643,31 @@ public void IncompleteAtEndOfFileWithIdentifier() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2813,21 +3676,22 @@ public void IncompleteAtEndOfFileWithIdentifier() } M(SyntaxKind.SemicolonToken); } + EOF(); } [Fact] public void MixedParensAndAngles_01() { - UsingStatement("delegate* cdecl' expected - // delegate* cdecl", ";").WithLocation(1, 26), - // (1,26): error CS1001: Identifier expected - // delegate* cdecl' expected + // delegate* unmanaged[cdecl]", ";").WithLocation(1, 37), + // (1,37): error CS1001: Identifier expected + // delegate* unmanaged[cdecl] ptr;", options: TestOptions.RegularPreview, - // (1,16): error CS1003: Syntax error, '<' expected - // delegate* cdecl(void> ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("<", "(").WithLocation(1, 16), - // (1,21): error CS1003: Syntax error, ',' expected - // delegate* cdecl(void> ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments(",", ">").WithLocation(1, 21), - // (1,26): error CS1003: Syntax error, '>' expected - // delegate* cdecl(void> ptr; - Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments(">", ";").WithLocation(1, 26), - // (1,26): error CS1001: Identifier expected - // delegate* cdecl(void> ptr; - Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 26)); + UsingStatement("delegate* unmanaged[cdecl](void> ptr;", options: TestOptions.RegularPreview, + // (1,27): error CS1003: Syntax error, '<' expected + // delegate* unmanaged[cdecl](void> ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments("<", "(").WithLocation(1, 27), + // (1,32): error CS1003: Syntax error, ',' expected + // delegate* unmanaged[cdecl](void> ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments(",", ">").WithLocation(1, 32), + // (1,37): error CS1003: Syntax error, '>' expected + // delegate* unmanaged[cdecl](void> ptr; + Diagnostic(ErrorCode.ERR_SyntaxError, ";").WithArguments(">", ";").WithLocation(1, 37), + // (1,37): error CS1001: Identifier expected + // delegate* unmanaged[cdecl](void> ptr; + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 37)); N(SyntaxKind.LocalDeclarationStatement); { N(SyntaxKind.VariableDeclaration); @@ -2882,17 +3760,31 @@ public void MixedParensAndAngles_02() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, "cdecl"); - M(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + N(SyntaxKind.FunctionPointerParameterList); + { + M(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2904,29 +3796,24 @@ public void MixedParensAndAngles_02() EOF(); } - [InlineData("cdecl")] - [InlineData("managed")] - [InlineData("stdcall")] - [InlineData("thiscall")] - [Theory] - public void ValidCallingConventionNextLine(string convention) + [Fact] + public void CallingConventionNextLine() { UsingNode($@" void C() {{ delegate* - {convention} + unmanaged[Cdecl] }}", options: TestOptions.RegularPreview, - // (5,10): error CS1003: Syntax error, '<' expected - // {convention} - Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("<", "").WithLocation(5, convention.Length + 5), - // (5,10): error CS1001: Identifier expected - // {convention} - Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(5, convention.Length + 5), - // (5,10): error CS1002: ; expected - // {convention} - Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(5, convention.Length + 5)); - + // (5,21): error CS1003: Syntax error, '<' expected + // unmanaged[Cdecl] + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("<", "").WithLocation(5, 21), + // (5,21): error CS1001: Identifier expected + // unmanaged[Cdecl] + Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(5, 21), + // (5,21): error CS1002: ; expected + // unmanaged[Cdecl] + Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(5, 21)); N(SyntaxKind.CompilationUnit); { N(SyntaxKind.GlobalStatement); @@ -2954,17 +3841,31 @@ void C() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.IdentifierToken, convention); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerCallingConvention); + { + N(SyntaxKind.UnmanagedKeyword); + N(SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.FunctionPointerUnmanagedCallingConvention); + { + N(SyntaxKind.IdentifierToken, "Cdecl"); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -2989,7 +3890,7 @@ public void InvalidCallingConventionNextLine() void C() { delegate* - int ptr = 1; + int[] ptr = 1; }", options: TestOptions.RegularPreview, // (4,14): error CS1003: Syntax error, '<' expected // delegate* @@ -3028,16 +3929,18 @@ void C() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - M(SyntaxKind.LessThanToken); - M(SyntaxKind.Parameter); + M(SyntaxKind.FunctionPointerParameterList); { - M(SyntaxKind.IdentifierName); + M(SyntaxKind.LessThanToken); + M(SyntaxKind.FunctionPointerParameter); { - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } } - M(SyntaxKind.IdentifierToken); + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.GreaterThanToken); } M(SyntaxKind.VariableDeclarator); { @@ -3050,9 +3953,21 @@ void C() { N(SyntaxKind.VariableDeclaration); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.ArrayType); { - N(SyntaxKind.IntKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } } N(SyntaxKind.VariableDeclarator); { @@ -3082,6 +3997,8 @@ void C() public void SyntaxFacts() { Assert.True(CSharp.SyntaxFacts.IsTypeSyntax(SyntaxKind.FunctionPointerType)); + Assert.True(CSharp.SyntaxFacts.IsContextualKeyword(SyntaxKind.ManagedKeyword)); + Assert.True(CSharp.SyntaxFacts.IsContextualKeyword(SyntaxKind.UnmanagedKeyword)); } [Fact] @@ -3104,16 +4021,18 @@ public void FunctionPointerArrayInTypeArgument() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } N(SyntaxKind.ArrayRankSpecifier); { @@ -3175,16 +4094,18 @@ public void UsingAlias() { N(SyntaxKind.DelegateKeyword); N(SyntaxKind.AsteriskToken); - N(SyntaxKind.LessThanToken); - N(SyntaxKind.Parameter); + N(SyntaxKind.FunctionPointerParameterList); { - N(SyntaxKind.PredefinedType); + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); { - N(SyntaxKind.VoidKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } } - M(SyntaxKind.IdentifierToken); + N(SyntaxKind.GreaterThanToken); } - N(SyntaxKind.GreaterThanToken); } } N(SyntaxKind.GlobalStatement); diff --git a/src/Compilers/Core/Portable/PEWriter/Members.cs b/src/Compilers/Core/Portable/PEWriter/Members.cs index d55f223b05c63..aa246979731a4 100644 --- a/src/Compilers/Core/Portable/PEWriter/Members.cs +++ b/src/Compilers/Core/Portable/PEWriter/Members.cs @@ -56,6 +56,13 @@ internal enum CallingConvention /// ThisCall = SignatureCallingConvention.ThisCall, + /// + /// Extensible calling convention protocol. This represents either the union of calling convention modopts after the paramcount specifier + /// in IL, or platform default if none are present + /// + // PROTOTYPE(func-ptr): Use the SRM version + Unmanaged = 0x9, + /// /// The convention for calling a generic method. /// diff --git a/src/Compilers/Test/Utilities/CSharp/FunctionPointerUtilities.cs b/src/Compilers/Test/Utilities/CSharp/FunctionPointerUtilities.cs index 56096f1e30a9f..f5795e8fa91ae 100644 --- a/src/Compilers/Test/Utilities/CSharp/FunctionPointerUtilities.cs +++ b/src/Compilers/Test/Utilities/CSharp/FunctionPointerUtilities.cs @@ -174,7 +174,7 @@ public static void VerifyFunctionPointerSemanticInfo( switch (syntax) { - case FunctionPointerTypeSyntax { Parameters: var paramSyntaxes }: + case FunctionPointerTypeSyntax { ParameterList: { Parameters: var paramSyntaxes } }: verifyNestedFunctionPointerSyntaxSemanticInfo(model, (IFunctionPointerTypeSymbol)exprType, paramSyntaxes); break; @@ -232,7 +232,7 @@ static void verifySymbolInfo( } } - static void verifyNestedFunctionPointerSyntaxSemanticInfo(SemanticModel model, IFunctionPointerTypeSymbol ptrType, SeparatedSyntaxList paramSyntaxes) + static void verifyNestedFunctionPointerSyntaxSemanticInfo(SemanticModel model, IFunctionPointerTypeSymbol ptrType, SeparatedSyntaxList paramSyntaxes) { // https://github.com/dotnet/roslyn/issues/43321 Nullability in type syntaxes that don't have an origin bound node // can differ. @@ -258,7 +258,7 @@ static void assertEqualSemanticInformation(SemanticModel model, TypeSyntax typeS Assert.Equal(signatureType, semanticInfo.Type, SymbolEqualityComparer.Default); Assert.Empty(semanticInfo.CandidateSymbols); - if (typeSyntax is FunctionPointerTypeSyntax { Parameters: var paramSyntaxes }) + if (typeSyntax is FunctionPointerTypeSyntax { ParameterList: { Parameters: var paramSyntaxes } }) { var paramPtrType = (IFunctionPointerTypeSymbol)semanticInfo.Type!; CommonVerifyFunctionPointer(paramPtrType.GetSymbol()); diff --git a/src/Test/Utilities/Portable/TestResource.resx b/src/Test/Utilities/Portable/TestResource.resx index 494f5fc6038f2..cb6d8b34f7d68 100644 --- a/src/Test/Utilities/Portable/TestResource.resx +++ b/src/Test/Utilities/Portable/TestResource.resx @@ -419,6 +419,10 @@ namespace My return; yield return this.items[3]; yield break; + delegate*<int, string, void> fp1 = null; + delegate* managed<int, string, void> fp2 = null; + delegate* unmanaged<int, string, void> fp3 = null; + delegate* unmanaged[Cdecl]<int, string, void> fp4 = null; fixed (int* p = stackalloc int[100], q = &y) { *intref = 1; @@ -3011,4 +3015,4 @@ Module Program End Sub End Module - \ No newline at end of file + diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs index a0e154e46f5e5..d7e53173c40bf 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs @@ -1088,7 +1088,7 @@ public static bool IsParameterModifierContext( if (token.IsKind(SyntaxKind.CommaToken) && token.Parent.IsKind(SyntaxKindEx.FunctionPointerType, out FunctionPointerTypeSyntax funcPtrType)) { - var commaIndex = funcPtrType.Parameters.GetWithSeparators().IndexOf(token); + var commaIndex = funcPtrType.ParameterList.Parameters.GetWithSeparators().IndexOf(token); parameterIndex = commaIndex / 2 + 1; return true; diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs index 845736e89b515..83b6de572cd97 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs @@ -134,10 +134,10 @@ public override TypeSyntax VisitFunctionPointerType(IFunctionPointerTypeSymbol s .Concat(SpecializedCollections.SingletonEnumerable(( Type: symbol.Signature.ReturnType, RefKindModifiers: CSharpSyntaxGenerator.GetParameterModifiers(symbol.Signature.RefKind, forFunctionPointerReturnParameter: true)))) - .SelectAsArray(t => SyntaxFactory.Parameter(SyntaxFactory.MissingToken(SyntaxKind.IdentifierToken)).WithModifiers(t.RefKindModifiers).WithType(t.Type.GenerateTypeSyntax())); + .SelectAsArray(t => SyntaxFactory.FunctionPointerParameter(t.Type.GenerateTypeSyntax()).WithModifiers(t.RefKindModifiers)); return AddInformationTo( - SyntaxFactory.FunctionPointerType(SyntaxFactory.SeparatedList(parameters)), symbol); + SyntaxFactory.FunctionPointerType(callingConvention: null, SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.SeparatedList(parameters))), symbol); } #endif From 4060db8879a459235ae738f3e891ab1ebe76d219 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Mon, 6 Jul 2020 17:14:26 -0700 Subject: [PATCH 04/13] Update IDE code. --- .../CSharp/Portable/Parser/LanguageParser.cs | 12 +- .../CSharp/Portable/PublicAPI.Unshipped.txt | 114 ++++++++++++++++-- .../Syntax/Parsing/FunctionPointerTests.cs | 42 +++++++ .../LessAndGreaterThanCompletionSession.cs | 2 +- .../DiagnosticAnalyzerDriverTests.cs | 1 - .../ReadOnlyKeywordRecommender.cs | 2 +- .../FormattingTests_FunctionPointers.cs | 82 ++++++++++++- .../CSharp/Formatting/FormattingHelpers.cs | 2 +- .../Formatting/Rules/SpacingFormattingRule.cs | 87 +++++++++++-- .../CSharp/Formatting/Rules/SyntaxKindEx.cs | 14 +++ .../ContextQuery/SyntaxTreeExtensions.cs | 22 +++- 11 files changed, 339 insertions(+), 41 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs index 38f8cb3a03af1..616560403562a 100644 --- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs +++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs @@ -6401,11 +6401,13 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) if (CurrentToken.Kind == SyntaxKind.IdentifierToken) { + var peek1 = PeekToken(1); switch (CurrentToken) { case { ContextualKind: SyntaxKind.ManagedKeyword }: case { ContextualKind: SyntaxKind.UnmanagedKeyword }: - case var _ when PeekToken(1).Kind == SyntaxKind.OpenBracketToken: + case var _ when IsPossibleFunctionPointerParameterListStart(peek1): + case var _ when peek1.Kind == SyntaxKind.OpenBracketToken: lastTokenOfType = EatToken(); break; @@ -7008,6 +7010,7 @@ PostSkipAction skipBadFunctionPointerTokens(SeparatedSyntaxListBuilder lis if (CurrentToken.Kind == SyntaxKind.IdentifierToken) { SyntaxToken managedSpecifier; + SyntaxToken peek1 = PeekToken(1); switch (CurrentToken) { case { ContextualKind: SyntaxKind.ManagedKeyword }: @@ -7015,7 +7018,12 @@ PostSkipAction skipBadFunctionPointerTokens(SeparatedSyntaxListBuilder lis managedSpecifier = EatContextualToken(CurrentToken.ContextualKind); break; - case var _ when PeekToken(1).Kind == SyntaxKind.OpenBracketToken: + case var _ when IsPossibleFunctionPointerParameterListStart(peek1): + // If there's a possible parameter list next, treat this as a bad identifier that should have been managed or unmanaged + managedSpecifier = EatTokenAsKind(SyntaxKind.ManagedKeyword); + break; + + case var _ when peek1.Kind == SyntaxKind.OpenBracketToken: // If there's an open brace next, treat this as a bad identifier that should have been unmanaged managedSpecifier = EatTokenAsKind(SyntaxKind.UnmanagedKeyword); break; diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index 30758aea6c0e0..124f5d225cae0 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -1,6 +1,54 @@ *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedSpecifier.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedSpecifier(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifiers(Microsoft.CodeAnalysis.SyntaxTokenList modifiers) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.CallingConvention.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.AddCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.CallingConventions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax @@ -29,9 +77,16 @@ Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithOpenBraceToken( Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithSemicolonToken(Microsoft.CodeAnalysis.SyntaxToken semicolonToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.WithTypeParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.TypeParameterListSyntax typeParameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerCallingConvention = 9059 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameter = 9057 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerParameterList = 9058 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConvention = 9067 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerUnmanagedCallingConventionList = 9066 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.ManagedKeyword = 8445 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind Microsoft.CodeAnalysis.CSharp.SyntaxKind.PrimaryConstructorBaseType = 9065 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordDeclaration = 9063 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind Microsoft.CodeAnalysis.CSharp.SyntaxKind.RecordKeyword = 8444 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +Microsoft.CodeAnalysis.CSharp.SyntaxKind.UnmanagedKeyword = 8446 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken @@ -39,26 +94,40 @@ Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver Microsoft.CodeAnalysis.CSharp.LanguageVersion.CSharp9 = 900 -> Microsoft.CodeAnalysis.CSharp.LanguageVersion Microsoft.CodeAnalysis.CSharp.CSharpGeneratorDriver.CSharpGeneratorDriver(Microsoft.CodeAnalysis.ParseOptions parseOptions, System.Collections.Immutable.ImmutableArray generators, Microsoft.CodeAnalysis.Diagnostics.AnalyzerConfigOptionsProvider optionsProvider, System.Collections.Immutable.ImmutableArray additionalTexts) -> void Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AsteriskToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.CallingConvention.get -> Microsoft.CodeAnalysis.SyntaxToken Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.DelegateKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.SyntaxToken callingConvention, Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithAsteriskToken(Microsoft.CodeAnalysis.SyntaxToken asteriskToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.SyntaxToken callingConvention) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithDelegateKeyword(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.SyntaxKind.FunctionPointerType = 9056 -> Microsoft.CodeAnalysis.CSharp.SyntaxKind +abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList +abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList +abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList +override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList +override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult override Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax @@ -78,9 +147,15 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.TypeParame static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken callingConvention, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.SyntaxToken callingConvention, Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType() -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax @@ -182,6 +257,9 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax.Accept Microsoft.CodeAnalysis.IMethodSymbol static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax @@ -194,10 +272,18 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.C static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, Microsoft.CodeAnalysis.SyntaxToken identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.CodeAnalysis.SyntaxToken keyword, string identifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> TResult static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax @@ -219,6 +305,8 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitTypePattern(Micro virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.UnaryPatternSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> TResult diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs index fb962a9d36862..cf77dcb0a2f7a 100644 --- a/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs +++ b/src/Compilers/CSharp/Test/Syntax/Parsing/FunctionPointerTests.cs @@ -336,6 +336,48 @@ public void InvalidConventionWithUnmanagedSpecifiers() EOF(); } + [Fact] + public void InvalidConventionFollowedByTypeArguments() + { + UsingStatement("delegate* invalid ptr;", options: TestOptions.RegularPreview, + // (1,11): error CS1003: Syntax error, 'managed' expected + // delegate* invalid + Diagnostic(ErrorCode.ERR_SyntaxError, "invalid").WithArguments("managed", "").WithLocation(1, 11)); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.FunctionPointerType); + { + N(SyntaxKind.DelegateKeyword); + N(SyntaxKind.AsteriskToken); + M(SyntaxKind.FunctionPointerCallingConvention); + { + M(SyntaxKind.ManagedKeyword); + } + N(SyntaxKind.FunctionPointerParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.FunctionPointerParameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "ptr"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + [Fact] public void EmptyUnmanagedSpecifierBraces() { diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs index efe914d0f9f85..1f7be9aac57db 100644 --- a/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs +++ b/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs @@ -35,7 +35,7 @@ public override bool CheckOpeningPoint(IBraceCompletionSession session, Cancella // type argument or parameter list if (!token.CheckParent(n => n.LessThanToken == token) && !token.CheckParent(n => n.LessThanToken == token) && - !token.CheckParent(n => n.LessThanToken == token) && + !token.CheckParent(n => n.LessThanToken == token) && !PossibleTypeArgument(snapshot, token, cancellationToken)) { return false; diff --git a/src/EditorFeatures/CSharpTest/Diagnostics/DiagnosticAnalyzerDriver/DiagnosticAnalyzerDriverTests.cs b/src/EditorFeatures/CSharpTest/Diagnostics/DiagnosticAnalyzerDriver/DiagnosticAnalyzerDriverTests.cs index 691120f393770..fdd3f60ba70cb 100644 --- a/src/EditorFeatures/CSharpTest/Diagnostics/DiagnosticAnalyzerDriver/DiagnosticAnalyzerDriverTests.cs +++ b/src/EditorFeatures/CSharpTest/Diagnostics/DiagnosticAnalyzerDriver/DiagnosticAnalyzerDriverTests.cs @@ -44,7 +44,6 @@ public async Task DiagnosticAnalyzerDriverAllInOne() // https://github.com/dotnet/roslyn/issues/44682 - Add to all in one missingSyntaxNodes.Add(SyntaxKind.WithExpression); missingSyntaxNodes.Add(SyntaxKind.RecordDeclaration); - missingSyntaxNodes.Add(SyntaxKind.FunctionPointerType); var analyzer = new CSharpTrackingDiagnosticAnalyzer(); using var workspace = TestWorkspace.CreateCSharp(source, TestOptions.Regular); diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs index c041476ea6c74..974ee641c4fa1 100644 --- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs +++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs @@ -43,7 +43,7 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context private static bool IsRefReadOnlyContext(CSharpSyntaxContext context) => context.TargetToken.IsKind(SyntaxKind.RefKeyword) && (context.TargetToken.Parent.IsKind(SyntaxKind.RefType) || - (context.TargetToken.Parent.IsKind(SyntaxKind.Parameter) && context.IsFunctionPointerTypeArgumentContext)); + (context.TargetToken.Parent.IsKind(SyntaxKind.FunctionPointerParameter) && context.IsFunctionPointerTypeArgumentContext)); private static bool IsValidContextForType(CSharpSyntaxContext context, CancellationToken cancellationToken) { diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs index 7f9bc9ed9bab1..33ded2689ab02 100644 --- a/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs +++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs @@ -14,11 +14,10 @@ public class FormattingTests_FunctionPointers : CSharpFormattingTestBase [Fact] public async Task FormatFunctionPointer() { - // TODO(https://github.com/dotnet/roslyn/issues/44312): add a space after the "int"s in the baseline and make this test still pass var content = @" unsafe class C { - delegate * < int, int> functionPointer; + delegate * < int , int > functionPointer; }"; var expected = @" @@ -31,19 +30,90 @@ unsafe class C } [Fact] - public async Task FormatFunctionPointerWithCallingConvention() + public async Task FormatFunctionPointerWithManagedCallingConvention() { - // TODO(https://github.com/dotnet/roslyn/issues/44312): add a space after the "int"s in the baseline and make this test still pass var content = @" unsafe class C { - delegate *cdecl < int, int> functionPointer; + delegate *managed < int , int > functionPointer; }"; var expected = @" unsafe class C { - delegate* cdecl functionPointer; + delegate* managed functionPointer; +}"; + + await AssertFormatAsync(expected, content); + } + + [Fact] + public async Task FormatFunctionPointerWithUnmanagedCallingConvention() + { + var content = @" +unsafe class C +{ + delegate *unmanaged < int , int > functionPointer; +}"; + + var expected = @" +unsafe class C +{ + delegate* unmanaged functionPointer; +}"; + + await AssertFormatAsync(expected, content); + } + + [Fact] + public async Task FormatFunctionPointerWithUnmanagedCallingConventionAndSpecifiers() + { + var content = @" +unsafe class C +{ + delegate *unmanaged [ Cdecl , Thiscall ] < int , int > functionPointer; +}"; + + var expected = @" +unsafe class C +{ + delegate* unmanaged[Cdecl, Thiscall] functionPointer; +}"; + + await AssertFormatAsync(expected, content); + } + + [Fact(Skip = "PROTOTYPE(func-ptr): Even though the rule is returning put a space, it's getting ignored, resulting in delegate*invalid <")] + public async Task FormatFunctionPointerWithUnrecognizedCallingConvention() + { + var content = @" +unsafe class C +{ + delegate *invalid < int , int > functionPointer; +}"; + + var expected = @" +unsafe class C +{ + delegate* invalid functionPointer; +}"; + + await AssertFormatAsync(expected, content); + } + + [Fact(Skip = "PROTOTYPE(func-ptr): Even though the rule is returning put a space, it's getting ignored, resulting in delegate*invalid [")] + public async Task FormatFunctionPointerWithInvalidCallingConventionAndSpecifiers() + { + var content = @" +unsafe class C +{ + delegate *invalid [ Cdecl , Thiscall ] < int , int > functionPointer; +}"; + + var expected = @" +unsafe class C +{ + delegate* invalid[Cdecl, Thiscall] functionPointer; }"; await AssertFormatAsync(expected, content); diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs index a7c0c277e5529..1f6839459bbfa 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/FormattingHelpers.cs @@ -109,7 +109,7 @@ public static bool IsColonInTypeBaseList(this SyntaxToken token) => token.Kind() == SyntaxKind.ColonToken && token.Parent.IsKind(SyntaxKind.BaseList); public static bool IsCommaInArgumentOrParameterList(this SyntaxToken token) - => token.Kind() == SyntaxKind.CommaToken && (token.Parent.IsAnyArgumentList() || token.Parent.IsKind(SyntaxKind.ParameterList)); + => token.Kind() == SyntaxKind.CommaToken && (token.Parent.IsAnyArgumentList() || token.Parent.IsKind(SyntaxKind.ParameterList) || token.Parent.IsKind(SyntaxKindEx.FunctionPointerParameterList)); public static bool IsLambdaBodyBlock(this SyntaxNode node) { diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs index 1320654d0015c..224c393b18164 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SpacingFormattingRule.cs @@ -321,7 +321,7 @@ previousToken.Parent is AssignmentExpressionSyntax || } // Function pointer type adjustments - if (previousParentKind == SyntaxKindEx.FunctionPointerType && currentParentKind == SyntaxKindEx.FunctionPointerType) + if (previousParentKind == SyntaxKindEx.FunctionPointerType) { // No spacing between delegate and * if (currentKind == SyntaxKind.AsteriskToken && previousKind == SyntaxKind.DelegateKeyword) @@ -330,23 +330,88 @@ previousToken.Parent is AssignmentExpressionSyntax || } // Force a space between * and the calling convention - if (currentKind == SyntaxKind.IdentifierToken && previousKind == SyntaxKind.AsteriskToken) + if (previousKind == SyntaxKind.AsteriskToken && currentParentKind == SyntaxKindEx.FunctionPointerCallingConvention) { - return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + switch (currentKind) + { + case SyntaxKind.IdentifierToken: + case SyntaxKindEx.ManagedKeyword: + case SyntaxKindEx.UnmanagedKeyword: + return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + } + } + } + + if (currentParentKind == SyntaxKindEx.FunctionPointerParameterList && currentKind == SyntaxKind.LessThanToken) + { + switch (previousKind) + { + // No spacing between the * and < tokens if there is no calling convention + case SyntaxKind.AsteriskToken: + // No spacing between the calling convention and opening angle bracket of function pointer types: + // delegate* managed< + case SyntaxKindEx.ManagedKeyword: + case SyntaxKindEx.UnmanagedKeyword: + // No spacing between the calling convention specifier and the opening angle + // delegate* unmanaged[Cdecl]< + case SyntaxKind.CloseBracketToken when previousParentKind == SyntaxKindEx.FunctionPointerUnmanagedCallingConventionList: + return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); } + } + + // No space between unmanaged and the [ + // delegate* unmanaged[ + if (previousParentKind == SyntaxKindEx.FunctionPointerCallingConvention && currentParentKind == SyntaxKindEx.FunctionPointerUnmanagedCallingConventionList && currentKind == SyntaxKind.OpenBracketToken) + { + return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + } - if (currentKind == SyntaxKind.LessThanToken) + // Function pointer calling convention adjustments + if (currentParentKind == SyntaxKindEx.FunctionPointerUnmanagedCallingConventionList && previousParentKind == SyntaxKindEx.FunctionPointerUnmanagedCallingConventionList) + { + if (currentKind == SyntaxKind.IdentifierToken) { - switch (previousKind) + // No space after the [ + // unmanaged[Cdecl + if (previousKind == SyntaxKind.OpenBracketToken) { - // No spacing between the * and < tokens if there is no calling convention - case SyntaxKind.AsteriskToken: - // No spacing between the calling convention and opening angle bracket of function pointer types: - // delegate* cdecl< - case SyntaxKind.IdentifierToken: - return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + } + // Space after the , + // unmanaged[Cdecl, Thiscall + else if (previousKind == SyntaxKind.CommaToken) + { + return CreateAdjustSpacesOperation(1, AdjustSpacesOption.ForceSpacesIfOnSingleLine); } } + + // No space between identifier and comma + // unmanaged[Cdecl, + if (currentKind == SyntaxKind.CommaToken) + { + return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + } + + // No space before the ] + // unmanaged[Cdecl] + if (currentKind == SyntaxKind.CloseBracketToken) + { + return CreateAdjustSpacesOperation(0, AdjustSpacesOption.ForceSpacesIfOnSingleLine); + } + } + + // Respect spacing setting for after the < in function pointer parameter lists + // delegate* in function pointer parameter lists + // delegate* + if (currentKind == SyntaxKind.GreaterThanToken && currentParentKind == SyntaxKindEx.FunctionPointerParameterList) + { + return AdjustSpacesOperationZeroOrOne(_options.SpaceWithinMethodDeclarationParenthesis); } // For spacing after the 'not' pattern operator diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SyntaxKindEx.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SyntaxKindEx.cs index 8f5d47e026bf4..48b521c5e806f 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SyntaxKindEx.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Compiler/CSharp/Formatting/Rules/SyntaxKindEx.cs @@ -27,6 +27,13 @@ internal static class SyntaxKindEx public const SyntaxKind NotKeyword = (SyntaxKind)8440; public const SyntaxKind DataKeyword = (SyntaxKind)8441; public const SyntaxKind RecordDeclaration = (SyntaxKind)9063; + public const SyntaxKind ManagedKeyword = (SyntaxKind)8445; + public const SyntaxKind UnmanagedKeyword = (SyntaxKind)8446; + public const SyntaxKind FunctionPointerParameter = (SyntaxKind)9057; + public const SyntaxKind FunctionPointerParameterList = (SyntaxKind)9058; + public const SyntaxKind FunctionPointerCallingConvention = (SyntaxKind)9059; + public const SyntaxKind FunctionPointerUnmanagedCallingConventionList = (SyntaxKind)9066; + public const SyntaxKind FunctionPointerUnmanagedCallingConvention = (SyntaxKind)9067; #if !CODE_STYLE private const uint ImplicitObjectCreationExpressionAssertion = -(ImplicitObjectCreationExpression - SyntaxKind.ImplicitObjectCreationExpression); @@ -50,6 +57,13 @@ internal static class SyntaxKindEx private const uint FunctionPointerTypeAssertion = -(FunctionPointerType - SyntaxKind.FunctionPointerType); private const uint NotKeywordValueAssertion = -(NotKeyword - SyntaxKind.NotKeyword); private const uint RecordDeclarationValueAssertion = -(RecordDeclaration - SyntaxKind.RecordDeclaration); + private const uint ManagedKeywordValueAssertion = -(ManagedKeyword - SyntaxKind.ManagedKeyword); + private const uint UnmanagedKeywordValueAssertion = -(UnmanagedKeyword - SyntaxKind.UnmanagedKeyword); + private const uint FunctionPointerParameterValueAssertion = -(FunctionPointerParameter - SyntaxKind.FunctionPointerParameter); + private const uint FunctionPointerParameterListValueAssertion = -(FunctionPointerParameterList - SyntaxKind.FunctionPointerParameterList); + private const uint FunctionPointerCallingConventionValueAssertion = -(FunctionPointerCallingConvention - SyntaxKind.FunctionPointerCallingConvention); + private const uint FunctionPointerUnmanagecCallingConventionListValueAssertion = -(FunctionPointerUnmanagedCallingConventionList - SyntaxKind.FunctionPointerUnmanagedCallingConventionList); + private const uint FunctionPointerUnmanagecCallingConventionValueAssertion = -(FunctionPointerUnmanagedCallingConvention - SyntaxKind.FunctionPointerUnmanagedCallingConvention); #endif } } diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs index d7e53173c40bf..e16e3d871724c 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs @@ -961,15 +961,27 @@ public static bool IsFunctionPointerTypeArgumentContext( { case SyntaxKind.LessThanToken: case SyntaxKind.CommaToken: - return token.Parent is FunctionPointerTypeSyntax; + return token.Parent is FunctionPointerParameterList; } - return token.Parent is ParameterSyntax { Parent: FunctionPointerTypeSyntax _ }; + return token.IsFunctionPointerParameterOrReturnType(); #else return false; #endif } + public static bool IsFunctionPointerParameterOrReturnType(this SyntaxToken syntaxToken) + { + return syntaxToken switch + { + // ref modifiers + { Parent: { RawKind: (int)SyntaxKindEx.FunctionPointerParameter } } => true, + // Regular type specifiers + { Parent: { Parent: { RawKind: (int)SyntaxKindEx.FunctionPointerParameter } } } => true, + _ => false + }; + } + public static bool IsGenericTypeArgumentContext( this SyntaxTree syntaxTree, int position, @@ -1068,7 +1080,7 @@ public static bool IsParameterModifierContext( return true; } - if (token.IsKind(SyntaxKind.LessThanToken) && token.Parent.IsKind(SyntaxKindEx.FunctionPointerType)) + if (token.IsKind(SyntaxKind.LessThanToken) && token.Parent.IsKind(SyntaxKindEx.FunctionPointerParameterList)) { parameterIndex = 0; return true; @@ -1086,9 +1098,9 @@ public static bool IsParameterModifierContext( #if !CODE_STYLE if (token.IsKind(SyntaxKind.CommaToken) && - token.Parent.IsKind(SyntaxKindEx.FunctionPointerType, out FunctionPointerTypeSyntax funcPtrType)) + token.Parent.IsKind(SyntaxKindEx.FunctionPointerParameterList, out FunctionPointerParameterList funcPtrParamList)) { - var commaIndex = funcPtrType.ParameterList.Parameters.GetWithSeparators().IndexOf(token); + var commaIndex = funcPtrParamList.Parameters.GetWithSeparators().IndexOf(token); parameterIndex = commaIndex / 2 + 1; return true; From 5a8c76240d2bdc5ea35ca277571a2bd2a468d9fb Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Mon, 6 Jul 2020 17:27:26 -0700 Subject: [PATCH 05/13] Fix FunctionPointerUnmanagedCallingConventionListSyntax naming. --- .../Portable/Generated/CSharp.Generated.g4 | 6 +- .../Syntax.xml.Internal.Generated.cs | 68 +++++++++---------- .../Generated/Syntax.xml.Main.Generated.cs | 28 ++++---- .../Generated/Syntax.xml.Syntax.Generated.cs | 34 +++++----- .../CSharp/Portable/Parser/LanguageParser.cs | 4 +- .../CSharp/Portable/PublicAPI.Unshipped.txt | 40 +++++------ .../FunctionPointerMethodSymbol.cs | 2 +- .../CSharp/Portable/Syntax/Syntax.xml | 4 +- .../Generated/Syntax.Test.xml.Generated.cs | 34 +++++----- 9 files changed, 110 insertions(+), 110 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 index ff06cdb8379df..6dc45d08fbddc 100644 --- a/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 +++ b/src/Compilers/CSharp/Portable/Generated/CSharp.Generated.g4 @@ -352,11 +352,11 @@ function_pointer_type ; function_pointer_calling_convention - : 'managed' function_pointer_unmanaged_calling_convention_syntax_list? - | 'unmanaged' function_pointer_unmanaged_calling_convention_syntax_list? + : 'managed' function_pointer_unmanaged_calling_convention_list? + | 'unmanaged' function_pointer_unmanaged_calling_convention_list? ; -function_pointer_unmanaged_calling_convention_syntax_list +function_pointer_unmanaged_calling_convention_list : '[' function_pointer_unmanaged_calling_convention (',' function_pointer_unmanaged_calling_convention)* ']' ; diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 4cd89ee2e75c1..92bd717eb3a49 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1324,9 +1324,9 @@ static FunctionPointerParameterList() internal sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode { internal readonly SyntaxToken managedSpecifier; - internal readonly FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList; + internal readonly FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList; - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 2; @@ -1339,7 +1339,7 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList, SyntaxFactoryContext context) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); @@ -1353,7 +1353,7 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) : base(kind) { this.SlotCount = 2; @@ -1369,7 +1369,7 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man /// SyntaxToken representing whether the calling convention is managed or unmanaged. public SyntaxToken ManagedSpecifier => this.managedSpecifier; /// Optional list of identifiers that will contribute to an unmanaged calling convention. - public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionList => this.unmanagedCallingConventionList; + public FunctionPointerUnmanagedCallingConventionListSyntax? UnmanagedCallingConventionList => this.unmanagedCallingConventionList; internal override GreenNode? GetSlot(int index) => index switch @@ -1384,7 +1384,7 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) { if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { @@ -1414,7 +1414,7 @@ internal FunctionPointerCallingConventionSyntax(ObjectReader reader) var managedSpecifier = (SyntaxToken)reader.ReadValue(); AdjustFlagsAndWidth(managedSpecifier); this.managedSpecifier = managedSpecifier; - var unmanagedCallingConventionList = (FunctionPointerUnmanagedCallingConventionSyntaxList?)reader.ReadValue(); + var unmanagedCallingConventionList = (FunctionPointerUnmanagedCallingConventionListSyntax?)reader.ReadValue(); if (unmanagedCallingConventionList != null) { AdjustFlagsAndWidth(unmanagedCallingConventionList); @@ -1436,13 +1436,13 @@ static FunctionPointerCallingConventionSyntax() } /// Function pointer calling convention syntax. - internal sealed partial class FunctionPointerUnmanagedCallingConventionSyntaxList : CSharpSyntaxNode + internal sealed partial class FunctionPointerUnmanagedCallingConventionListSyntax : CSharpSyntaxNode { internal readonly SyntaxToken openBracketToken; internal readonly GreenNode? callingConventions; internal readonly SyntaxToken closeBracketToken; - internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 3; @@ -1457,7 +1457,7 @@ internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, Sy this.closeBracketToken = closeBracketToken; } - internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, SyntaxFactoryContext context) + internal FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); @@ -1473,7 +1473,7 @@ internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, Sy this.closeBracketToken = closeBracketToken; } - internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken) + internal FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind kind, SyntaxToken openBracketToken, GreenNode? callingConventions, SyntaxToken closeBracketToken) : base(kind) { this.SlotCount = 3; @@ -1504,16 +1504,16 @@ internal FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind kind, Sy _ => null, }; - internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList(this, parent, position); + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax(this, parent, position); - public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); - public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionList(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionList(this); - public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + public FunctionPointerUnmanagedCallingConventionListSyntax Update(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { if (openBracketToken != this.OpenBracketToken || callingConventions != this.CallingConventions || closeBracketToken != this.CloseBracketToken) { - var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracketToken, callingConventions, closeBracketToken); + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(openBracketToken, callingConventions, closeBracketToken); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1527,12 +1527,12 @@ public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken op } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerUnmanagedCallingConventionSyntaxList(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, diagnostics, GetAnnotations()); + => new FunctionPointerUnmanagedCallingConventionListSyntax(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerUnmanagedCallingConventionSyntaxList(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, GetDiagnostics(), annotations); + => new FunctionPointerUnmanagedCallingConventionListSyntax(this.Kind, this.openBracketToken, this.callingConventions, this.closeBracketToken, GetDiagnostics(), annotations); - internal FunctionPointerUnmanagedCallingConventionSyntaxList(ObjectReader reader) + internal FunctionPointerUnmanagedCallingConventionListSyntax(ObjectReader reader) : base(reader) { this.SlotCount = 3; @@ -1558,9 +1558,9 @@ internal override void WriteTo(ObjectWriter writer) writer.WriteValue(this.closeBracketToken); } - static FunctionPointerUnmanagedCallingConventionSyntaxList() + static FunctionPointerUnmanagedCallingConventionListSyntax() { - ObjectBinder.RegisterTypeReader(typeof(FunctionPointerUnmanagedCallingConventionSyntaxList), r => new FunctionPointerUnmanagedCallingConventionSyntaxList(r)); + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerUnmanagedCallingConventionListSyntax), r => new FunctionPointerUnmanagedCallingConventionListSyntax(r)); } } @@ -32885,7 +32885,7 @@ internal partial class CSharpSyntaxVisitor public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); - public virtual TResult VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); public virtual TResult VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitTupleType(TupleTypeSyntax node) => this.DefaultVisit(node); @@ -33119,7 +33119,7 @@ internal partial class CSharpSyntaxVisitor public virtual void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); - public virtual void VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); public virtual void VisitNullableType(NullableTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitTupleType(TupleTypeSyntax node) => this.DefaultVisit(node); @@ -33375,9 +33375,9 @@ public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPoint => node.Update((SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); public override CSharpSyntaxNode VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList)Visit(node.UnmanagedCallingConventionList)); + => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionListSyntax)Visit(node.UnmanagedCallingConventionList)); - public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) + public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => node.Update((SyntaxToken)Visit(node.OpenBracketToken), VisitList(node.CallingConventions), (SyntaxToken)Visit(node.CloseBracketToken)); public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) @@ -34287,7 +34287,7 @@ public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken les return result; } - public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { #if DEBUG if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); @@ -34312,7 +34312,7 @@ public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(S return result; } - public FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + public FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { #if DEBUG if (openBracketToken == null) throw new ArgumentNullException(nameof(openBracketToken)); @@ -34323,9 +34323,9 @@ public FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmana int hash; var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, this.context, out hash); - if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntaxList)cached; + if (cached != null) return (FunctionPointerUnmanagedCallingConventionListSyntax)cached; - var result = new FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, this.context); + var result = new FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, this.context); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -39162,7 +39162,7 @@ public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxTo return result; } - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { #if DEBUG if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); @@ -39187,7 +39187,7 @@ public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConve return result; } - public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + public static FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { #if DEBUG if (openBracketToken == null) throw new ArgumentNullException(nameof(openBracketToken)); @@ -39198,9 +39198,9 @@ public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointe int hash; var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken, out hash); - if (cached != null) return (FunctionPointerUnmanagedCallingConventionSyntaxList)cached; + if (cached != null) return (FunctionPointerUnmanagedCallingConventionListSyntax)cached; - var result = new FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken); + var result = new FunctionPointerUnmanagedCallingConventionListSyntax(SyntaxKind.FunctionPointerUnmanagedCallingConventionList, openBracketToken, callingConventions.Node, closeBracketToken); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -43801,7 +43801,7 @@ internal static IEnumerable GetNodeTypes() typeof(FunctionPointerTypeSyntax), typeof(FunctionPointerParameterList), typeof(FunctionPointerCallingConventionSyntax), - typeof(FunctionPointerUnmanagedCallingConventionSyntaxList), + typeof(FunctionPointerUnmanagedCallingConventionListSyntax), typeof(FunctionPointerUnmanagedCallingConventionSyntax), typeof(NullableTypeSyntax), typeof(TupleTypeSyntax), diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs index bf1ad5cba66b0..cb449d2519dd4 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs @@ -63,9 +63,9 @@ public partial class CSharpSyntaxVisitor [return: MaybeNull] public virtual TResult VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); - /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntaxList node. + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionListSyntax node. [return: MaybeNull] - public virtual TResult VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntax node. [return: MaybeNull] @@ -974,8 +974,8 @@ public partial class CSharpSyntaxVisitor /// Called when the visitor visits a FunctionPointerCallingConventionSyntax node. public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); - /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntaxList node. - public virtual void VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionListSyntax node. + public virtual void VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); /// Called when the visitor visits a FunctionPointerUnmanagedCallingConventionSyntax node. public virtual void VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); @@ -1665,9 +1665,9 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor => node.Update(VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); public override SyntaxNode? VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionSyntaxList?)Visit(node.UnmanagedCallingConventionList)); + => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionListSyntax?)Visit(node.UnmanagedCallingConventionList)); - public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConventionSyntaxList(FunctionPointerUnmanagedCallingConventionSyntaxList node) + public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => node.Update(VisitToken(node.OpenBracketToken), VisitList(node.CallingConventions), VisitToken(node.CloseBracketToken)); public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) @@ -2485,7 +2485,7 @@ public static FunctionPointerParameterList FunctionPointerParameterList(Separate => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); /// Creates a new FunctionPointerCallingConventionSyntax instance. - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { switch (managedSpecifier.Kind()) { @@ -2493,24 +2493,24 @@ public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConve case SyntaxKind.UnmanagedKeyword: break; default: throw new ArgumentException(nameof(managedSpecifier)); } - return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionList == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)unmanagedCallingConventionList.Green).CreateRed(); + return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionList == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)unmanagedCallingConventionList.Green).CreateRed(); } /// Creates a new FunctionPointerCallingConventionSyntax instance. public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier) => SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, default); - /// Creates a new FunctionPointerUnmanagedCallingConventionSyntaxList instance. - public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + /// Creates a new FunctionPointerUnmanagedCallingConventionListSyntax instance. + public static FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { if (openBracketToken.Kind() != SyntaxKind.OpenBracketToken) throw new ArgumentException(nameof(openBracketToken)); if (closeBracketToken.Kind() != SyntaxKind.CloseBracketToken) throw new ArgumentException(nameof(closeBracketToken)); - return (FunctionPointerUnmanagedCallingConventionSyntaxList)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList((Syntax.InternalSyntax.SyntaxToken)openBracketToken.Node!, callingConventions.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)closeBracketToken.Node!).CreateRed(); + return (FunctionPointerUnmanagedCallingConventionListSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList((Syntax.InternalSyntax.SyntaxToken)openBracketToken.Node!, callingConventions.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)closeBracketToken.Node!).CreateRed(); } - /// Creates a new FunctionPointerUnmanagedCallingConventionSyntaxList instance. - public static FunctionPointerUnmanagedCallingConventionSyntaxList FunctionPointerUnmanagedCallingConventionSyntaxList(SeparatedSyntaxList callingConventions = default) - => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + /// Creates a new FunctionPointerUnmanagedCallingConventionListSyntax instance. + public static FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SeparatedSyntaxList callingConventions = default) + => SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), callingConventions, SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); /// Creates a new FunctionPointerUnmanagedCallingConventionSyntax instance. public static FunctionPointerUnmanagedCallingConventionSyntax FunctionPointerUnmanagedCallingConvention(SyntaxToken name) diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index 84301c14fbab6..f34325bf78a08 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -583,7 +583,7 @@ public FunctionPointerParameterList Update(SyntaxToken lessThanToken, SeparatedS /// Function pointer calling convention syntax. public sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode { - private FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList; + private FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList; internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) @@ -594,7 +594,7 @@ internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode public SyntaxToken ManagedSpecifier => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)this.Green).managedSpecifier, Position, 0); /// Optional list of identifiers that will contribute to an unmanaged calling convention. - public FunctionPointerUnmanagedCallingConventionSyntaxList? UnmanagedCallingConventionList => GetRed(ref this.unmanagedCallingConventionList, 1); + public FunctionPointerUnmanagedCallingConventionListSyntax? UnmanagedCallingConventionList => GetRed(ref this.unmanagedCallingConventionList, 1); internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.unmanagedCallingConventionList, 1) : null; @@ -604,7 +604,7 @@ internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { @@ -617,27 +617,27 @@ public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifie } public FunctionPointerCallingConventionSyntax WithManagedSpecifier(SyntaxToken managedSpecifier) => Update(managedSpecifier, this.UnmanagedCallingConventionList); - public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventionList) => Update(this.ManagedSpecifier, unmanagedCallingConventionList); + public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) => Update(this.ManagedSpecifier, unmanagedCallingConventionList); public FunctionPointerCallingConventionSyntax AddUnmanagedCallingConventionListCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) { - var unmanagedCallingConventionList = this.UnmanagedCallingConventionList ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(); + var unmanagedCallingConventionList = this.UnmanagedCallingConventionList ?? SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(); return WithUnmanagedCallingConventionList(unmanagedCallingConventionList.WithCallingConventions(unmanagedCallingConventionList.CallingConventions.AddRange(items))); } } /// Function pointer calling convention syntax. - public sealed partial class FunctionPointerUnmanagedCallingConventionSyntaxList : CSharpSyntaxNode + public sealed partial class FunctionPointerUnmanagedCallingConventionListSyntax : CSharpSyntaxNode { private SyntaxNode? callingConventions; - internal FunctionPointerUnmanagedCallingConventionSyntaxList(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + internal FunctionPointerUnmanagedCallingConventionListSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) { } /// SyntaxToken representing open bracket. - public SyntaxToken OpenBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)this.Green).openBracketToken, Position, 0); + public SyntaxToken OpenBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)this.Green).openBracketToken, Position, 0); /// SeparatedSyntaxList of calling convention identifiers. public SeparatedSyntaxList CallingConventions @@ -650,21 +650,21 @@ public SeparatedSyntaxList Call } /// SyntaxToken representing close bracket. - public SyntaxToken CloseBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList)this.Green).closeBracketToken, GetChildPosition(2), GetChildIndex(2)); + public SyntaxToken CloseBracketToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)this.Green).closeBracketToken, GetChildPosition(2), GetChildIndex(2)); internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.callingConventions, 1)! : null; internal override SyntaxNode? GetCachedSlot(int index) => index == 1 ? this.callingConventions : null; - public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionList(this); [return: MaybeNull] - public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(this); + public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerUnmanagedCallingConventionList(this); - public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) + public FunctionPointerUnmanagedCallingConventionListSyntax Update(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) { if (openBracketToken != this.OpenBracketToken || callingConventions != this.CallingConventions || closeBracketToken != this.CloseBracketToken) { - var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracketToken, callingConventions, closeBracketToken); + var newNode = SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(openBracketToken, callingConventions, closeBracketToken); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -672,11 +672,11 @@ public FunctionPointerUnmanagedCallingConventionSyntaxList Update(SyntaxToken op return this; } - public FunctionPointerUnmanagedCallingConventionSyntaxList WithOpenBracketToken(SyntaxToken openBracketToken) => Update(openBracketToken, this.CallingConventions, this.CloseBracketToken); - public FunctionPointerUnmanagedCallingConventionSyntaxList WithCallingConventions(SeparatedSyntaxList callingConventions) => Update(this.OpenBracketToken, callingConventions, this.CloseBracketToken); - public FunctionPointerUnmanagedCallingConventionSyntaxList WithCloseBracketToken(SyntaxToken closeBracketToken) => Update(this.OpenBracketToken, this.CallingConventions, closeBracketToken); + public FunctionPointerUnmanagedCallingConventionListSyntax WithOpenBracketToken(SyntaxToken openBracketToken) => Update(openBracketToken, this.CallingConventions, this.CloseBracketToken); + public FunctionPointerUnmanagedCallingConventionListSyntax WithCallingConventions(SeparatedSyntaxList callingConventions) => Update(this.OpenBracketToken, callingConventions, this.CloseBracketToken); + public FunctionPointerUnmanagedCallingConventionListSyntax WithCloseBracketToken(SyntaxToken closeBracketToken) => Update(this.OpenBracketToken, this.CallingConventions, closeBracketToken); - public FunctionPointerUnmanagedCallingConventionSyntaxList AddCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) => WithCallingConventions(this.CallingConventions.AddRange(items)); + public FunctionPointerUnmanagedCallingConventionListSyntax AddCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) => WithCallingConventions(this.CallingConventions.AddRange(items)); } /// Individual function pointer unmanaged calling convention. diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs index 616560403562a..8364ba52c54ce 100644 --- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs +++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs @@ -7034,7 +7034,7 @@ PostSkipAction skipBadFunctionPointerTokens(SeparatedSyntaxListBuilder lis return null; } - FunctionPointerUnmanagedCallingConventionSyntaxList? unmanagedCallingConventions = null; + FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventions = null; if (CurrentToken.Kind == SyntaxKind.OpenBracketToken) { var openBracket = EatToken(SyntaxKind.OpenBracketToken); @@ -7059,7 +7059,7 @@ PostSkipAction skipBadFunctionPointerTokens(SeparatedSyntaxListBuilder lis var closeBracket = EatToken(SyntaxKind.CloseBracketToken); - unmanagedCallingConventions = SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(openBracket, callingConventionModifiers, closeBracket); + unmanagedCallingConventions = SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(openBracket, callingConventionModifiers, closeBracket); } finally { diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index 124f5d225cae0..ce7918e6ccda4 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -10,10 +10,10 @@ Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.Code Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedSpecifier.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedSpecifier(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken @@ -40,15 +40,15 @@ Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSy Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.WithName(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.AddCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.CallingConventions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.AddCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.CallingConventions.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.CloseBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.OpenBracketToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCallingConventions(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithCloseBracketToken(Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.WithOpenBracketToken(Microsoft.CodeAnalysis.SyntaxToken openBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax @@ -107,7 +107,7 @@ override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointer override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode -override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void @@ -123,8 +123,8 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(M override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult -override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void -override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList override Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax @@ -148,7 +148,7 @@ static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(t static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList @@ -258,8 +258,8 @@ static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(this Mic static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.BinaryPattern(Microsoft.CodeAnalysis.CSharp.SyntaxKind kind, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax left, Microsoft.CodeAnalysis.SyntaxToken operatorToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax right) -> Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SyntaxToken openBracketToken, Microsoft.CodeAnalysis.SeparatedSyntaxList callingConventions, Microsoft.CodeAnalysis.SyntaxToken closeBracketToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression() -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ImplicitObjectCreationExpression(Microsoft.CodeAnalysis.SyntaxToken newKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax @@ -277,7 +277,7 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerPa virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> void -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> void @@ -306,7 +306,7 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Micr virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> TResult -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionSyntaxList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntaxList node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> TResult diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs index 8b2356a067d95..199036e8cc671 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs @@ -121,7 +121,7 @@ static CallingConvention getCallingConvention(FunctionPointerCallingConventionSy return CallingConvention.Default; } - static bool isCallingConvention(FunctionPointerUnmanagedCallingConventionSyntaxList specifiers, string expected) + static bool isCallingConvention(FunctionPointerUnmanagedCallingConventionListSyntax specifiers, string expected) => specifiers.CallingConventions[0].Name.Text == expected; } } diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml index a965ce68616ca..84319c6b0ae30 100644 --- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml +++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml @@ -283,13 +283,13 @@ SyntaxToken representing whether the calling convention is managed or unmanaged. - + Optional list of identifiers that will contribute to an unmanaged calling convention. - + Function pointer calling convention syntax. diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs index 6aeb1b9809f28..126a5c23432c6 100644 --- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs +++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs @@ -46,8 +46,8 @@ private static Syntax.InternalSyntax.FunctionPointerParameterList GenerateFuncti private static Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() => InternalSyntaxFactory.FunctionPointerCallingConvention(InternalSyntaxFactory.Token(SyntaxKind.ManagedKeyword), null); - private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntaxList GenerateFunctionPointerUnmanagedCallingConventionSyntaxList() - => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(InternalSyntaxFactory.Token(SyntaxKind.OpenBracketToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax GenerateFunctionPointerUnmanagedCallingConventionList() + => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConventionList(InternalSyntaxFactory.Token(SyntaxKind.OpenBracketToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.CloseBracketToken)); private static Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() => InternalSyntaxFactory.FunctionPointerUnmanagedCallingConvention(InternalSyntaxFactory.Identifier("Name")); @@ -840,9 +840,9 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListFactoryAndProperties() + public void TestFunctionPointerUnmanagedCallingConventionListFactoryAndProperties() { - var node = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var node = GenerateFunctionPointerUnmanagedCallingConventionList(); Assert.Equal(SyntaxKind.OpenBracketToken, node.OpenBracketToken.Kind); Assert.Equal(default, node.CallingConventions); @@ -3962,9 +3962,9 @@ public void TestFunctionPointerCallingConventionIdentityRewriter() } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRewriter() + public void TestFunctionPointerUnmanagedCallingConventionListTokenDeleteRewriter() { - var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionList(); var rewriter = new TokenDeleteRewriter(); var newNode = rewriter.Visit(oldNode); @@ -3978,9 +3978,9 @@ public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRe } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListIdentityRewriter() + public void TestFunctionPointerUnmanagedCallingConventionListIdentityRewriter() { - var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionList(); var rewriter = new IdentityRewriter(); var newNode = rewriter.Visit(oldNode); @@ -9668,10 +9668,10 @@ private static FunctionPointerParameterList GenerateFunctionPointerParameterList => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); private static FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() - => SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionSyntaxList)); + => SyntaxFactory.FunctionPointerCallingConvention(SyntaxFactory.Token(SyntaxKind.ManagedKeyword), default(FunctionPointerUnmanagedCallingConventionListSyntax)); - private static FunctionPointerUnmanagedCallingConventionSyntaxList GenerateFunctionPointerUnmanagedCallingConventionSyntaxList() - => SyntaxFactory.FunctionPointerUnmanagedCallingConventionSyntaxList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); + private static FunctionPointerUnmanagedCallingConventionListSyntax GenerateFunctionPointerUnmanagedCallingConventionList() + => SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(SyntaxFactory.Token(SyntaxKind.OpenBracketToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.CloseBracketToken)); private static FunctionPointerUnmanagedCallingConventionSyntax GenerateFunctionPointerUnmanagedCallingConvention() => SyntaxFactory.FunctionPointerUnmanagedCallingConvention(SyntaxFactory.Identifier("Name")); @@ -10464,9 +10464,9 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListFactoryAndProperties() + public void TestFunctionPointerUnmanagedCallingConventionListFactoryAndProperties() { - var node = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var node = GenerateFunctionPointerUnmanagedCallingConventionList(); Assert.Equal(SyntaxKind.OpenBracketToken, node.OpenBracketToken.Kind()); Assert.Equal(default, node.CallingConventions); @@ -13586,9 +13586,9 @@ public void TestFunctionPointerCallingConventionIdentityRewriter() } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRewriter() + public void TestFunctionPointerUnmanagedCallingConventionListTokenDeleteRewriter() { - var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionList(); var rewriter = new TokenDeleteRewriter(); var newNode = rewriter.Visit(oldNode); @@ -13602,9 +13602,9 @@ public void TestFunctionPointerUnmanagedCallingConventionSyntaxListTokenDeleteRe } [Fact] - public void TestFunctionPointerUnmanagedCallingConventionSyntaxListIdentityRewriter() + public void TestFunctionPointerUnmanagedCallingConventionListIdentityRewriter() { - var oldNode = GenerateFunctionPointerUnmanagedCallingConventionSyntaxList(); + var oldNode = GenerateFunctionPointerUnmanagedCallingConventionList(); var rewriter = new IdentityRewriter(); var newNode = rewriter.Visit(oldNode); From c39f1648f8047700eec07ae6eba4f5d7ef8f8ce4 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Mon, 6 Jul 2020 18:41:41 -0700 Subject: [PATCH 06/13] Fixup public api, formatting, and suppressions. --- src/Compilers/CSharp/Portable/GlobalSuppressions.cs | 4 ++-- src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt | 3 --- src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt | 9 ++++++--- src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs | 4 ++-- 4 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/Compilers/CSharp/Portable/GlobalSuppressions.cs b/src/Compilers/CSharp/Portable/GlobalSuppressions.cs index 2f30945ffdf54..3cca9d1097648 100644 --- a/src/Compilers/CSharp/Portable/GlobalSuppressions.cs +++ b/src/Compilers/CSharp/Portable/GlobalSuppressions.cs @@ -34,7 +34,7 @@ [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(System.String,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Text.Encoding,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken)~Microsoft.CodeAnalysis.SyntaxTree")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(Microsoft.CodeAnalysis.Text.SourceText,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,Microsoft.CodeAnalysis.ReportDiagnostic},System.Nullable{System.Boolean},System.Threading.CancellationToken)~Microsoft.CodeAnalysis.SyntaxTree")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.DeconstructionPatternClause(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.SubpatternSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.DeconstructionPatternClauseSyntax")] -[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.IMethodSymbol")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.SymbolInfo")] -[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetMemberGroup(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken)~System.Collections.Immutable.ImmutableArray{Microsoft.CodeAnalysis.ISymbol}")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList")] diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt index ab1cb7856ea7c..6aa612f8966f0 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt @@ -1721,11 +1721,8 @@ Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsof Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Default.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList -Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index ce7918e6ccda4..766eee2bf09a4 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -107,7 +107,7 @@ override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointer override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode -override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void @@ -277,7 +277,7 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerPa virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> void -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> void @@ -297,6 +297,9 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.Code *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.ArgumentList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.Initializer.get -> Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax *REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ObjectCreationExpressionSyntax.NewKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken +*REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList +*REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList +*REMOVED*Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax *REMOVED*static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParseTypeName(string text, int offset = 0, bool consumeFullText = true) -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> void @@ -306,7 +309,7 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitUnaryPattern(Micr virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitWithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitBinaryPattern(Microsoft.CodeAnalysis.CSharp.Syntax.BinaryPatternSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> TResult -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionListSyntax(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitImplicitObjectCreationExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ImplicitObjectCreationExpressionSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructorBaseType(Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax node) -> TResult diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs index 1abd627dd13fb..6aa98dd9cadb9 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKindFacts.cs @@ -1682,9 +1682,9 @@ public static string GetText(SyntaxKind kind) case SyntaxKind.RecordKeyword: return "record"; case SyntaxKind.ManagedKeyword: - return "managed"; + return "managed"; case SyntaxKind.UnmanagedKeyword: - return "unmanaged"; + return "unmanaged"; default: return string.Empty; } From 4f740fa0085a384c6003d99d8ca94aafadd854a9 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Tue, 7 Jul 2020 14:53:51 -0700 Subject: [PATCH 07/13] Fix FunctionPointerParameterList naming. --- .../Syntax.xml.Internal.Generated.cs | 62 +++++++++---------- .../Generated/Syntax.xml.Main.Generated.cs | 28 ++++----- .../Generated/Syntax.xml.Syntax.Generated.cs | 26 ++++---- .../CSharp/Portable/GlobalSuppressions.cs | 2 +- .../CSharp/Portable/PublicAPI.Unshipped.txt | 42 ++++++------- .../CSharp/Portable/Syntax/Syntax.xml | 4 +- .../Generated/Syntax.Test.xml.Generated.cs | 4 +- .../LessAndGreaterThanCompletionSession.cs | 2 +- .../ContextQuery/SyntaxTreeExtensions.cs | 4 +- 9 files changed, 87 insertions(+), 87 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 92bd717eb3a49..5a7bfe739d5ed 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1054,9 +1054,9 @@ internal sealed partial class FunctionPointerTypeSyntax : TypeSyntax internal readonly SyntaxToken delegateKeyword; internal readonly SyntaxToken asteriskToken; internal readonly FunctionPointerCallingConventionSyntax? callingConvention; - internal readonly FunctionPointerParameterList parameterList; + internal readonly FunctionPointerParameterListSyntax parameterList; - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 4; @@ -1073,7 +1073,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.parameterList = parameterList; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList, SyntaxFactoryContext context) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); @@ -1091,7 +1091,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, this.parameterList = parameterList; } - internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) : base(kind) { this.SlotCount = 4; @@ -1115,7 +1115,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, /// SyntaxToken representing the optional calling convention. public FunctionPointerCallingConventionSyntax? CallingConvention => this.callingConvention; /// List of the parameter types and return type of the function pointer. - public FunctionPointerParameterList ParameterList => this.parameterList; + public FunctionPointerParameterListSyntax ParameterList => this.parameterList; internal override GreenNode? GetSlot(int index) => index switch @@ -1132,7 +1132,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax callingConvention, FunctionPointerParameterList parameterList) + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax callingConvention, FunctionPointerParameterListSyntax parameterList) { if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameterList != this.ParameterList) { @@ -1171,7 +1171,7 @@ internal FunctionPointerTypeSyntax(ObjectReader reader) AdjustFlagsAndWidth(callingConvention); this.callingConvention = callingConvention; } - var parameterList = (FunctionPointerParameterList)reader.ReadValue(); + var parameterList = (FunctionPointerParameterListSyntax)reader.ReadValue(); AdjustFlagsAndWidth(parameterList); this.parameterList = parameterList; } @@ -1192,13 +1192,13 @@ static FunctionPointerTypeSyntax() } /// Function pointer parameter list syntax. - internal sealed partial class FunctionPointerParameterList : CSharpSyntaxNode + internal sealed partial class FunctionPointerParameterListSyntax : CSharpSyntaxNode { internal readonly SyntaxToken lessThanToken; internal readonly GreenNode? parameters; internal readonly SyntaxToken greaterThanToken; - internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerParameterListSyntax(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 3; @@ -1213,7 +1213,7 @@ internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken this.greaterThanToken = greaterThanToken; } - internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, SyntaxFactoryContext context) + internal FunctionPointerParameterListSyntax(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); @@ -1229,7 +1229,7 @@ internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken this.greaterThanToken = greaterThanToken; } - internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken) + internal FunctionPointerParameterListSyntax(SyntaxKind kind, SyntaxToken lessThanToken, GreenNode? parameters, SyntaxToken greaterThanToken) : base(kind) { this.SlotCount = 3; @@ -1260,12 +1260,12 @@ internal FunctionPointerParameterList(SyntaxKind kind, SyntaxToken lessThanToken _ => null, }; - internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerParameterList(this, parent, position); + internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) => new CSharp.Syntax.FunctionPointerParameterListSyntax(this, parent, position); public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); - public FunctionPointerParameterList Update(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerParameterListSyntax Update(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { if (lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) { @@ -1283,12 +1283,12 @@ public FunctionPointerParameterList Update(SyntaxToken lessThanToken, Microsoft. } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerParameterList(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, diagnostics, GetAnnotations()); + => new FunctionPointerParameterListSyntax(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerParameterList(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, GetDiagnostics(), annotations); + => new FunctionPointerParameterListSyntax(this.Kind, this.lessThanToken, this.parameters, this.greaterThanToken, GetDiagnostics(), annotations); - internal FunctionPointerParameterList(ObjectReader reader) + internal FunctionPointerParameterListSyntax(ObjectReader reader) : base(reader) { this.SlotCount = 3; @@ -1314,9 +1314,9 @@ internal override void WriteTo(ObjectWriter writer) writer.WriteValue(this.greaterThanToken); } - static FunctionPointerParameterList() + static FunctionPointerParameterListSyntax() { - ObjectBinder.RegisterTypeReader(typeof(FunctionPointerParameterList), r => new FunctionPointerParameterList(r)); + ObjectBinder.RegisterTypeReader(typeof(FunctionPointerParameterListSyntax), r => new FunctionPointerParameterListSyntax(r)); } } @@ -32883,7 +32883,7 @@ internal partial class CSharpSyntaxVisitor public virtual TResult VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) => this.DefaultVisit(node); public virtual TResult VisitPointerType(PointerTypeSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); - public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); public virtual TResult VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); @@ -33117,7 +33117,7 @@ internal partial class CSharpSyntaxVisitor public virtual void VisitArrayRankSpecifier(ArrayRankSpecifierSyntax node) => this.DefaultVisit(node); public virtual void VisitPointerType(PointerTypeSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); - public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => this.DefaultVisit(node); public virtual void VisitFunctionPointerUnmanagedCallingConvention(FunctionPointerUnmanagedCallingConventionSyntax node) => this.DefaultVisit(node); @@ -33369,9 +33369,9 @@ public override CSharpSyntaxNode VisitPointerType(PointerTypeSyntax node) => node.Update((TypeSyntax)Visit(node.ElementType), (SyntaxToken)Visit(node.AsteriskToken)); public override CSharpSyntaxNode VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (FunctionPointerCallingConventionSyntax)Visit(node.CallingConvention), (FunctionPointerParameterList)Visit(node.ParameterList)); + => node.Update((SyntaxToken)Visit(node.DelegateKeyword), (SyntaxToken)Visit(node.AsteriskToken), (FunctionPointerCallingConventionSyntax)Visit(node.CallingConvention), (FunctionPointerParameterListSyntax)Visit(node.ParameterList)); - public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPointerParameterList node) + public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => node.Update((SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); public override CSharpSyntaxNode VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) @@ -34252,7 +34252,7 @@ public PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken asteris return result; } - public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); @@ -34265,7 +34265,7 @@ public FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList, this.context); } - public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { #if DEBUG if (lessThanToken == null) throw new ArgumentNullException(nameof(lessThanToken)); @@ -34276,9 +34276,9 @@ public FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken les int hash; var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, this.context, out hash); - if (cached != null) return (FunctionPointerParameterList)cached; + if (cached != null) return (FunctionPointerParameterListSyntax)cached; - var result = new FunctionPointerParameterList(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, this.context); + var result = new FunctionPointerParameterListSyntax(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, this.context); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -39127,7 +39127,7 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType, SyntaxToken return result; } - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) { #if DEBUG if (delegateKeyword == null) throw new ArgumentNullException(nameof(delegateKeyword)); @@ -39140,7 +39140,7 @@ public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegate return new FunctionPointerTypeSyntax(SyntaxKind.FunctionPointerType, delegateKeyword, asteriskToken, callingConvention, parameterList); } - public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public static FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { #if DEBUG if (lessThanToken == null) throw new ArgumentNullException(nameof(lessThanToken)); @@ -39151,9 +39151,9 @@ public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxTo int hash; var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken, out hash); - if (cached != null) return (FunctionPointerParameterList)cached; + if (cached != null) return (FunctionPointerParameterListSyntax)cached; - var result = new FunctionPointerParameterList(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken); + var result = new FunctionPointerParameterListSyntax(SyntaxKind.FunctionPointerParameterList, lessThanToken, parameters.Node, greaterThanToken); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -43799,7 +43799,7 @@ internal static IEnumerable GetNodeTypes() typeof(ArrayRankSpecifierSyntax), typeof(PointerTypeSyntax), typeof(FunctionPointerTypeSyntax), - typeof(FunctionPointerParameterList), + typeof(FunctionPointerParameterListSyntax), typeof(FunctionPointerCallingConventionSyntax), typeof(FunctionPointerUnmanagedCallingConventionListSyntax), typeof(FunctionPointerUnmanagedCallingConventionSyntax), diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs index cb449d2519dd4..b96b17d85787a 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs @@ -55,9 +55,9 @@ public partial class CSharpSyntaxVisitor [return: MaybeNull] public virtual TResult VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); - /// Called when the visitor visits a FunctionPointerParameterList node. + /// Called when the visitor visits a FunctionPointerParameterListSyntax node. [return: MaybeNull] - public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + public virtual TResult VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => this.DefaultVisit(node); /// Called when the visitor visits a FunctionPointerCallingConventionSyntax node. [return: MaybeNull] @@ -968,8 +968,8 @@ public partial class CSharpSyntaxVisitor /// Called when the visitor visits a FunctionPointerTypeSyntax node. public virtual void VisitFunctionPointerType(FunctionPointerTypeSyntax node) => this.DefaultVisit(node); - /// Called when the visitor visits a FunctionPointerParameterList node. - public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterList node) => this.DefaultVisit(node); + /// Called when the visitor visits a FunctionPointerParameterListSyntax node. + public virtual void VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => this.DefaultVisit(node); /// Called when the visitor visits a FunctionPointerCallingConventionSyntax node. public virtual void VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) => this.DefaultVisit(node); @@ -1659,9 +1659,9 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor => node.Update((TypeSyntax?)Visit(node.ElementType) ?? throw new ArgumentNullException("elementType"), VisitToken(node.AsteriskToken)); public override SyntaxNode? VisitFunctionPointerType(FunctionPointerTypeSyntax node) - => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), (FunctionPointerCallingConventionSyntax?)Visit(node.CallingConvention), (FunctionPointerParameterList?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList")); + => node.Update(VisitToken(node.DelegateKeyword), VisitToken(node.AsteriskToken), (FunctionPointerCallingConventionSyntax?)Visit(node.CallingConvention), (FunctionPointerParameterListSyntax?)Visit(node.ParameterList) ?? throw new ArgumentNullException("parameterList")); - public override SyntaxNode? VisitFunctionPointerParameterList(FunctionPointerParameterList node) + public override SyntaxNode? VisitFunctionPointerParameterList(FunctionPointerParameterListSyntax node) => node.Update(VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); public override SyntaxNode? VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) @@ -2456,32 +2456,32 @@ public static PointerTypeSyntax PointerType(TypeSyntax elementType) => SyntaxFactory.PointerType(elementType, SyntaxFactory.Token(SyntaxKind.AsteriskToken)); /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + public static FunctionPointerTypeSyntax FunctionPointerType(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) { if (delegateKeyword.Kind() != SyntaxKind.DelegateKeyword) throw new ArgumentException(nameof(delegateKeyword)); if (asteriskToken.Kind() != SyntaxKind.AsteriskToken) throw new ArgumentException(nameof(asteriskToken)); if (parameterList == null) throw new ArgumentNullException(nameof(parameterList)); - return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, callingConvention == null ? null : (Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)callingConvention.Green, (Syntax.InternalSyntax.FunctionPointerParameterList)parameterList.Green).CreateRed(); + return (FunctionPointerTypeSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerType((Syntax.InternalSyntax.SyntaxToken)delegateKeyword.Node!, (Syntax.InternalSyntax.SyntaxToken)asteriskToken.Node!, callingConvention == null ? null : (Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)callingConvention.Green, (Syntax.InternalSyntax.FunctionPointerParameterListSyntax)parameterList.Green).CreateRed(); } /// Creates a new FunctionPointerTypeSyntax instance. - public static FunctionPointerTypeSyntax FunctionPointerType(FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + public static FunctionPointerTypeSyntax FunctionPointerType(FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), callingConvention, parameterList); /// Creates a new FunctionPointerTypeSyntax instance. public static FunctionPointerTypeSyntax FunctionPointerType() => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default, SyntaxFactory.FunctionPointerParameterList()); - /// Creates a new FunctionPointerParameterList instance. - public static FunctionPointerParameterList FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + /// Creates a new FunctionPointerParameterListSyntax instance. + public static FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { if (lessThanToken.Kind() != SyntaxKind.LessThanToken) throw new ArgumentException(nameof(lessThanToken)); if (greaterThanToken.Kind() != SyntaxKind.GreaterThanToken) throw new ArgumentException(nameof(greaterThanToken)); - return (FunctionPointerParameterList)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameterList((Syntax.InternalSyntax.SyntaxToken)lessThanToken.Node!, parameters.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)greaterThanToken.Node!).CreateRed(); + return (FunctionPointerParameterListSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerParameterList((Syntax.InternalSyntax.SyntaxToken)lessThanToken.Node!, parameters.Node.ToGreenSeparatedList(), (Syntax.InternalSyntax.SyntaxToken)greaterThanToken.Node!).CreateRed(); } - /// Creates a new FunctionPointerParameterList instance. - public static FunctionPointerParameterList FunctionPointerParameterList(SeparatedSyntaxList parameters = default) + /// Creates a new FunctionPointerParameterListSyntax instance. + public static FunctionPointerParameterListSyntax FunctionPointerParameterList(SeparatedSyntaxList parameters = default) => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); /// Creates a new FunctionPointerCallingConventionSyntax instance. diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index f34325bf78a08..6df767da3a856 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -468,7 +468,7 @@ public PointerTypeSyntax Update(TypeSyntax elementType, SyntaxToken asteriskToke public sealed partial class FunctionPointerTypeSyntax : TypeSyntax { private FunctionPointerCallingConventionSyntax? callingConvention; - private FunctionPointerParameterList? parameterList; + private FunctionPointerParameterListSyntax? parameterList; internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) @@ -485,7 +485,7 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax public FunctionPointerCallingConventionSyntax? CallingConvention => GetRed(ref this.callingConvention, 2); /// List of the parameter types and return type of the function pointer. - public FunctionPointerParameterList ParameterList => GetRed(ref this.parameterList, 3)!; + public FunctionPointerParameterListSyntax ParameterList => GetRed(ref this.parameterList, 3)!; internal override SyntaxNode? GetNodeSlot(int index) => index switch @@ -507,7 +507,7 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerType(this); - public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterList parameterList) + public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken asteriskToken, FunctionPointerCallingConventionSyntax? callingConvention, FunctionPointerParameterListSyntax parameterList) { if (delegateKeyword != this.DelegateKeyword || asteriskToken != this.AsteriskToken || callingConvention != this.CallingConvention || parameterList != this.ParameterList) { @@ -522,23 +522,23 @@ public FunctionPointerTypeSyntax Update(SyntaxToken delegateKeyword, SyntaxToken public FunctionPointerTypeSyntax WithDelegateKeyword(SyntaxToken delegateKeyword) => Update(delegateKeyword, this.AsteriskToken, this.CallingConvention, this.ParameterList); public FunctionPointerTypeSyntax WithAsteriskToken(SyntaxToken asteriskToken) => Update(this.DelegateKeyword, asteriskToken, this.CallingConvention, this.ParameterList); public FunctionPointerTypeSyntax WithCallingConvention(FunctionPointerCallingConventionSyntax? callingConvention) => Update(this.DelegateKeyword, this.AsteriskToken, callingConvention, this.ParameterList); - public FunctionPointerTypeSyntax WithParameterList(FunctionPointerParameterList parameterList) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, parameterList); + public FunctionPointerTypeSyntax WithParameterList(FunctionPointerParameterListSyntax parameterList) => Update(this.DelegateKeyword, this.AsteriskToken, this.CallingConvention, parameterList); public FunctionPointerTypeSyntax AddParameterListParameters(params FunctionPointerParameterSyntax[] items) => WithParameterList(this.ParameterList.WithParameters(this.ParameterList.Parameters.AddRange(items))); } /// Function pointer parameter list syntax. - public sealed partial class FunctionPointerParameterList : CSharpSyntaxNode + public sealed partial class FunctionPointerParameterListSyntax : CSharpSyntaxNode { private SyntaxNode? parameters; - internal FunctionPointerParameterList(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) + internal FunctionPointerParameterListSyntax(InternalSyntax.CSharpSyntaxNode green, SyntaxNode? parent, int position) : base(green, parent, position) { } /// SyntaxToken representing the less than token. - public SyntaxToken LessThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterList)this.Green).lessThanToken, Position, 0); + public SyntaxToken LessThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterListSyntax)this.Green).lessThanToken, Position, 0); /// SeparatedSyntaxList of ParameterSyntaxes representing the list of parameters and return type. public SeparatedSyntaxList Parameters @@ -551,7 +551,7 @@ public SeparatedSyntaxList Parameters } /// SyntaxToken representing the greater than token. - public SyntaxToken GreaterThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterList)this.Green).greaterThanToken, GetChildPosition(2), GetChildIndex(2)); + public SyntaxToken GreaterThanToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerParameterListSyntax)this.Green).greaterThanToken, GetChildPosition(2), GetChildIndex(2)); internal override SyntaxNode? GetNodeSlot(int index) => index == 1 ? GetRed(ref this.parameters, 1)! : null; @@ -561,7 +561,7 @@ public SeparatedSyntaxList Parameters [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerParameterList(this); - public FunctionPointerParameterList Update(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) + public FunctionPointerParameterListSyntax Update(SyntaxToken lessThanToken, SeparatedSyntaxList parameters, SyntaxToken greaterThanToken) { if (lessThanToken != this.LessThanToken || parameters != this.Parameters || greaterThanToken != this.GreaterThanToken) { @@ -573,11 +573,11 @@ public FunctionPointerParameterList Update(SyntaxToken lessThanToken, SeparatedS return this; } - public FunctionPointerParameterList WithLessThanToken(SyntaxToken lessThanToken) => Update(lessThanToken, this.Parameters, this.GreaterThanToken); - public FunctionPointerParameterList WithParameters(SeparatedSyntaxList parameters) => Update(this.LessThanToken, parameters, this.GreaterThanToken); - public FunctionPointerParameterList WithGreaterThanToken(SyntaxToken greaterThanToken) => Update(this.LessThanToken, this.Parameters, greaterThanToken); + public FunctionPointerParameterListSyntax WithLessThanToken(SyntaxToken lessThanToken) => Update(lessThanToken, this.Parameters, this.GreaterThanToken); + public FunctionPointerParameterListSyntax WithParameters(SeparatedSyntaxList parameters) => Update(this.LessThanToken, parameters, this.GreaterThanToken); + public FunctionPointerParameterListSyntax WithGreaterThanToken(SyntaxToken greaterThanToken) => Update(this.LessThanToken, this.Parameters, greaterThanToken); - public FunctionPointerParameterList AddParameters(params FunctionPointerParameterSyntax[] items) => WithParameters(this.Parameters.AddRange(items)); + public FunctionPointerParameterListSyntax AddParameters(params FunctionPointerParameterSyntax[] items) => WithParameters(this.Parameters.AddRange(items)); } /// Function pointer calling convention syntax. diff --git a/src/Compilers/CSharp/Portable/GlobalSuppressions.cs b/src/Compilers/CSharp/Portable/GlobalSuppressions.cs index 3cca9d1097648..ead96a1fadd99 100644 --- a/src/Compilers/CSharp/Portable/GlobalSuppressions.cs +++ b/src/Compilers/CSharp/Portable/GlobalSuppressions.cs @@ -37,4 +37,4 @@ [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetDeclaredSymbol(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.IMethodSymbol")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0026:Do not add multiple public overloads with optional parameters", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(Microsoft.CodeAnalysis.SemanticModel,Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax,System.Threading.CancellationToken)~Microsoft.CodeAnalysis.SymbolInfo")] [assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax")] -[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList")] +[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("ApiDesign", "RS0027:Public API with optional parameter(s) should have the most parameters amongst its public overloads.", Justification = "", Scope = "member", Target = "~M:Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList{Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax})~Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax")] diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index 766eee2bf09a4..a7ffd498f57f8 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -14,15 +14,15 @@ Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Unma Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedSpecifier(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.GreaterThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.LessThanToken.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Parameters.get -> Microsoft.CodeAnalysis.SeparatedSyntaxList +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithGreaterThanToken(Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithLessThanToken(Microsoft.CodeAnalysis.SyntaxToken lessThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.WithParameters(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax @@ -32,10 +32,10 @@ Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithModifier Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.AddParameterListParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.CallingConvention.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.ParameterList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax.WithParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Name.get -> Microsoft.CodeAnalysis.SyntaxToken Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken name) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax @@ -104,7 +104,7 @@ abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Modifiers.get abstract Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode -override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> Microsoft.CodeAnalysis.SyntaxNode +override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode @@ -112,8 +112,8 @@ override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitPrimaryConstruc override Microsoft.CodeAnalysis.CSharp.CSharpSyntaxRewriter.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> Microsoft.CodeAnalysis.SyntaxNode override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult -override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void -override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void +override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> void override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.Accept(Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor visitor) -> TResult override Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList @@ -151,11 +151,11 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvent static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SyntaxToken lessThanToken, Microsoft.CodeAnalysis.SeparatedSyntaxList parameters, Microsoft.CodeAnalysis.SyntaxToken greaterThanToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType() -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerType(Microsoft.CodeAnalysis.SyntaxToken delegateKeyword, Microsoft.CodeAnalysis.SyntaxToken asteriskToken, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax callingConvention, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax parameterList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.AddArgumentListArguments(params Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax.WithArgumentList(Microsoft.CodeAnalysis.CSharp.Syntax.ArgumentListSyntax argumentList) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseObjectCreationExpressionSyntax @@ -274,7 +274,7 @@ static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.RecordDeclaration(Microsoft.C static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.WithExpression(Microsoft.CodeAnalysis.CSharp.Syntax.ExpressionSyntax expression, Microsoft.CodeAnalysis.CSharp.Syntax.InitializerExpressionSyntax initializer) -> Microsoft.CodeAnalysis.CSharp.Syntax.WithExpressionSyntax virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> void -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> void +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax node) -> void @@ -283,7 +283,7 @@ virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitPrimaryConstructo virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitRecordDeclaration(Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax node) -> void virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerCallingConvention(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax node) -> TResult -virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterList node) -> TResult +virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerParameterList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax node) -> TResult virtual Microsoft.CodeAnalysis.CSharp.CSharpSyntaxVisitor.VisitFunctionPointerType(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerTypeSyntax node) -> TResult static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.ParenthesizedPattern(Microsoft.CodeAnalysis.SyntaxToken openParenToken, Microsoft.CodeAnalysis.CSharp.Syntax.PatternSyntax pattern, Microsoft.CodeAnalysis.SyntaxToken closeParenToken) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParenthesizedPatternSyntax diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml index 84319c6b0ae30..12481957cde05 100644 --- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml +++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml @@ -242,13 +242,13 @@ SyntaxToken representing the optional calling convention. - + List of the parameter types and return type of the function pointer. - + Function pointer parameter list syntax. diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs index 126a5c23432c6..16fb39d0c4d2d 100644 --- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs +++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs @@ -40,7 +40,7 @@ private static Syntax.InternalSyntax.PointerTypeSyntax GeneratePointerType() private static Syntax.InternalSyntax.FunctionPointerTypeSyntax GenerateFunctionPointerType() => InternalSyntaxFactory.FunctionPointerType(InternalSyntaxFactory.Token(SyntaxKind.DelegateKeyword), InternalSyntaxFactory.Token(SyntaxKind.AsteriskToken), null, GenerateFunctionPointerParameterList()); - private static Syntax.InternalSyntax.FunctionPointerParameterList GenerateFunctionPointerParameterList() + private static Syntax.InternalSyntax.FunctionPointerParameterListSyntax GenerateFunctionPointerParameterList() => InternalSyntaxFactory.FunctionPointerParameterList(InternalSyntaxFactory.Token(SyntaxKind.LessThanToken), new Microsoft.CodeAnalysis.Syntax.InternalSyntax.SeparatedSyntaxList(), InternalSyntaxFactory.Token(SyntaxKind.GreaterThanToken)); private static Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() @@ -9664,7 +9664,7 @@ private static PointerTypeSyntax GeneratePointerType() private static FunctionPointerTypeSyntax GenerateFunctionPointerType() => SyntaxFactory.FunctionPointerType(SyntaxFactory.Token(SyntaxKind.DelegateKeyword), SyntaxFactory.Token(SyntaxKind.AsteriskToken), default(FunctionPointerCallingConventionSyntax), GenerateFunctionPointerParameterList()); - private static FunctionPointerParameterList GenerateFunctionPointerParameterList() + private static FunctionPointerParameterListSyntax GenerateFunctionPointerParameterList() => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), new SeparatedSyntaxList(), SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); private static FunctionPointerCallingConventionSyntax GenerateFunctionPointerCallingConvention() diff --git a/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs b/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs index 1f7be9aac57db..62fdf4c6227d1 100644 --- a/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs +++ b/src/EditorFeatures/CSharp/AutomaticCompletion/Sessions/LessAndGreaterThanCompletionSession.cs @@ -35,7 +35,7 @@ public override bool CheckOpeningPoint(IBraceCompletionSession session, Cancella // type argument or parameter list if (!token.CheckParent(n => n.LessThanToken == token) && !token.CheckParent(n => n.LessThanToken == token) && - !token.CheckParent(n => n.LessThanToken == token) && + !token.CheckParent(n => n.LessThanToken == token) && !PossibleTypeArgument(snapshot, token, cancellationToken)) { return false; diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs index e16e3d871724c..eafa9143ac207 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs @@ -961,7 +961,7 @@ public static bool IsFunctionPointerTypeArgumentContext( { case SyntaxKind.LessThanToken: case SyntaxKind.CommaToken: - return token.Parent is FunctionPointerParameterList; + return token.Parent is FunctionPointerParameterListSyntax; } return token.IsFunctionPointerParameterOrReturnType(); @@ -1098,7 +1098,7 @@ public static bool IsParameterModifierContext( #if !CODE_STYLE if (token.IsKind(SyntaxKind.CommaToken) && - token.Parent.IsKind(SyntaxKindEx.FunctionPointerParameterList, out FunctionPointerParameterList funcPtrParamList)) + token.Parent.IsKind(SyntaxKindEx.FunctionPointerParameterList, out FunctionPointerParameterListSyntax funcPtrParamList)) { var commaIndex = funcPtrParamList.Parameters.GetWithSeparators().IndexOf(token); From c4be1376a6e0465ef35f3dd44267659f5d1f104e Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Tue, 7 Jul 2020 15:51:16 -0700 Subject: [PATCH 08/13] PR Feedback: * Revert unneeded publicapi file changes. * Simplify handling in some IDE code. --- .../CSharp/Portable/PublicAPI.Shipped.txt | 3 +++ .../ReadOnlyKeywordRecommender.cs | 3 +-- .../ContextQuery/SyntaxTreeExtensions.cs | 16 +++++----------- 3 files changed, 9 insertions(+), 13 deletions(-) diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt index 6aa612f8966f0..ab1cb7856ea7c 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Shipped.txt @@ -1721,8 +1721,11 @@ Microsoft.CodeAnalysis.CSharp.Syntax.ParameterListSyntax.WithParameters(Microsof Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AddModifiers(params Microsoft.CodeAnalysis.SyntaxToken[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.AttributeLists.get -> Microsoft.CodeAnalysis.SyntaxList Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Default.get -> Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Identifier.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Modifiers.get -> Microsoft.CodeAnalysis.SyntaxTokenList +Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Type.get -> Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.Update(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type, Microsoft.CodeAnalysis.SyntaxToken identifier, Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax.WithDefault(Microsoft.CodeAnalysis.CSharp.Syntax.EqualsValueClauseSyntax default) -> Microsoft.CodeAnalysis.CSharp.Syntax.ParameterSyntax diff --git a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs index 974ee641c4fa1..af17a9a0ec8b2 100644 --- a/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs +++ b/src/Features/CSharp/Portable/Completion/KeywordRecommenders/ReadOnlyKeywordRecommender.cs @@ -42,8 +42,7 @@ protected override bool IsValidContext(int position, CSharpSyntaxContext context private static bool IsRefReadOnlyContext(CSharpSyntaxContext context) => context.TargetToken.IsKind(SyntaxKind.RefKeyword) && - (context.TargetToken.Parent.IsKind(SyntaxKind.RefType) || - (context.TargetToken.Parent.IsKind(SyntaxKind.FunctionPointerParameter) && context.IsFunctionPointerTypeArgumentContext)); + (context.TargetToken.Parent.IsKind(SyntaxKind.RefType) || context.IsFunctionPointerTypeArgumentContext); private static bool IsValidContextForType(CSharpSyntaxContext context, CancellationToken cancellationToken) { diff --git a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs index eafa9143ac207..4bab51f9e3ebc 100644 --- a/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs +++ b/src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ContextQuery/SyntaxTreeExtensions.cs @@ -956,7 +956,6 @@ public static bool IsFunctionPointerTypeArgumentContext( var token = tokenOnLeftOfPosition; token = token.GetPreviousTokenIfTouchingWord(position); - // https://github.com/dotnet/roslyn/issues/39865: When the syntax rewrite is done, the parents here will need to change. switch (token.Kind()) { case SyntaxKind.LessThanToken: @@ -964,22 +963,17 @@ public static bool IsFunctionPointerTypeArgumentContext( return token.Parent is FunctionPointerParameterListSyntax; } - return token.IsFunctionPointerParameterOrReturnType(); -#else - return false; -#endif - } - - public static bool IsFunctionPointerParameterOrReturnType(this SyntaxToken syntaxToken) - { - return syntaxToken switch + return token switch { // ref modifiers { Parent: { RawKind: (int)SyntaxKindEx.FunctionPointerParameter } } => true, // Regular type specifiers - { Parent: { Parent: { RawKind: (int)SyntaxKindEx.FunctionPointerParameter } } } => true, + { Parent: TypeSyntax { Parent: { RawKind: (int)SyntaxKindEx.FunctionPointerParameter } } } => true, _ => false }; +#else + return false; +#endif } public static bool IsGenericTypeArgumentContext( From cdb5087dfc06d5c7b76185a16b2557901c81f39a Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Wed, 8 Jul 2020 16:23:36 -0700 Subject: [PATCH 09/13] PR Feedback: * Rename ManagedSpecifier for clarity. * Handle more cases in symbol binding and increase code clarity. * Deduplicate type checks when binding parameters. --- .../CSharp/Portable/CSharpResources.resx | 2 +- .../Syntax.xml.Internal.Generated.cs | 68 +++++++++--------- .../Generated/Syntax.xml.Main.Generated.cs | 14 ++-- .../Generated/Syntax.xml.Syntax.Generated.cs | 12 ++-- .../CSharp/Portable/Parser/LanguageParser.cs | 4 +- .../CSharp/Portable/PublicAPI.Unshipped.txt | 2 +- .../FunctionPointerMethodSymbol.cs | 71 +++++++++++++------ .../Symbols/Source/ParameterHelpers.cs | 48 ++++++------- .../CSharp/Portable/Syntax/Syntax.xml | 2 +- .../CSharp/Portable/Syntax/SyntaxKind.cs | 1 + .../Portable/xlf/CSharpResources.cs.xlf | 6 +- .../Portable/xlf/CSharpResources.de.xlf | 6 +- .../Portable/xlf/CSharpResources.es.xlf | 6 +- .../Portable/xlf/CSharpResources.fr.xlf | 6 +- .../Portable/xlf/CSharpResources.it.xlf | 6 +- .../Portable/xlf/CSharpResources.ja.xlf | 6 +- .../Portable/xlf/CSharpResources.ko.xlf | 6 +- .../Portable/xlf/CSharpResources.pl.xlf | 6 +- .../Portable/xlf/CSharpResources.pt-BR.xlf | 6 +- .../Portable/xlf/CSharpResources.ru.xlf | 6 +- .../Portable/xlf/CSharpResources.tr.xlf | 6 +- .../Portable/xlf/CSharpResources.zh-Hans.xlf | 6 +- .../Portable/xlf/CSharpResources.zh-Hant.xlf | 6 +- .../CodeGen/CodeGenFunctionPointersTests.cs | 29 ++++++++ .../Symbols/FunctionPointerTypeSymbolTests.cs | 26 +++++-- .../Generated/Syntax.Test.xml.Generated.cs | 6 +- 26 files changed, 219 insertions(+), 144 deletions(-) diff --git a/src/Compilers/CSharp/Portable/CSharpResources.resx b/src/Compilers/CSharp/Portable/CSharpResources.resx index 21f66e1a4b671..0af361336f5fd 100644 --- a/src/Compilers/CSharp/Portable/CSharpResources.resx +++ b/src/Compilers/CSharp/Portable/CSharpResources.resx @@ -6053,7 +6053,7 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ &method group - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. Internal error in the C# compiler. diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 5a7bfe739d5ed..1acd08d47dff9 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1323,15 +1323,15 @@ static FunctionPointerParameterListSyntax() /// Function pointer calling convention syntax. internal sealed partial class FunctionPointerCallingConventionSyntax : CSharpSyntaxNode { - internal readonly SyntaxToken managedSpecifier; + internal readonly SyntaxToken managedOrUnmanagedKeyword; internal readonly FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList; - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, DiagnosticInfo[]? diagnostics, SyntaxAnnotation[]? annotations) : base(kind, diagnostics, annotations) { this.SlotCount = 2; - this.AdjustFlagsAndWidth(managedSpecifier); - this.managedSpecifier = managedSpecifier; + this.AdjustFlagsAndWidth(managedOrUnmanagedKeyword); + this.managedOrUnmanagedKeyword = managedOrUnmanagedKeyword; if (unmanagedCallingConventionList != null) { this.AdjustFlagsAndWidth(unmanagedCallingConventionList); @@ -1339,13 +1339,13 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, SyntaxFactoryContext context) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList, SyntaxFactoryContext context) : base(kind) { this.SetFactoryContext(context); this.SlotCount = 2; - this.AdjustFlagsAndWidth(managedSpecifier); - this.managedSpecifier = managedSpecifier; + this.AdjustFlagsAndWidth(managedOrUnmanagedKeyword); + this.managedOrUnmanagedKeyword = managedOrUnmanagedKeyword; if (unmanagedCallingConventionList != null) { this.AdjustFlagsAndWidth(unmanagedCallingConventionList); @@ -1353,12 +1353,12 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man } } - internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) + internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) : base(kind) { this.SlotCount = 2; - this.AdjustFlagsAndWidth(managedSpecifier); - this.managedSpecifier = managedSpecifier; + this.AdjustFlagsAndWidth(managedOrUnmanagedKeyword); + this.managedOrUnmanagedKeyword = managedOrUnmanagedKeyword; if (unmanagedCallingConventionList != null) { this.AdjustFlagsAndWidth(unmanagedCallingConventionList); @@ -1367,14 +1367,14 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man } /// SyntaxToken representing whether the calling convention is managed or unmanaged. - public SyntaxToken ManagedSpecifier => this.managedSpecifier; + public SyntaxToken ManagedOrUnmanagedKeyword => this.managedOrUnmanagedKeyword; /// Optional list of identifiers that will contribute to an unmanaged calling convention. public FunctionPointerUnmanagedCallingConventionListSyntax? UnmanagedCallingConventionList => this.unmanagedCallingConventionList; internal override GreenNode? GetSlot(int index) => index switch { - 0 => this.managedSpecifier, + 0 => this.managedOrUnmanagedKeyword, 1 => this.unmanagedCallingConventionList, _ => null, }; @@ -1384,11 +1384,11 @@ internal FunctionPointerCallingConventionSyntax(SyntaxKind kind, SyntaxToken man public override void Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) { - if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) + if (managedOrUnmanagedKeyword != this.ManagedOrUnmanagedKeyword || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { - var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionList); + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, unmanagedCallingConventionList); var diags = GetDiagnostics(); if (diags?.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); @@ -1402,18 +1402,18 @@ public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifie } internal override GreenNode SetDiagnostics(DiagnosticInfo[]? diagnostics) - => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionList, diagnostics, GetAnnotations()); + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedOrUnmanagedKeyword, this.unmanagedCallingConventionList, diagnostics, GetAnnotations()); internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedSpecifier, this.unmanagedCallingConventionList, GetDiagnostics(), annotations); + => new FunctionPointerCallingConventionSyntax(this.Kind, this.managedOrUnmanagedKeyword, this.unmanagedCallingConventionList, GetDiagnostics(), annotations); internal FunctionPointerCallingConventionSyntax(ObjectReader reader) : base(reader) { this.SlotCount = 2; - var managedSpecifier = (SyntaxToken)reader.ReadValue(); - AdjustFlagsAndWidth(managedSpecifier); - this.managedSpecifier = managedSpecifier; + var managedOrUnmanagedKeyword = (SyntaxToken)reader.ReadValue(); + AdjustFlagsAndWidth(managedOrUnmanagedKeyword); + this.managedOrUnmanagedKeyword = managedOrUnmanagedKeyword; var unmanagedCallingConventionList = (FunctionPointerUnmanagedCallingConventionListSyntax?)reader.ReadValue(); if (unmanagedCallingConventionList != null) { @@ -1425,7 +1425,7 @@ internal FunctionPointerCallingConventionSyntax(ObjectReader reader) internal override void WriteTo(ObjectWriter writer) { base.WriteTo(writer); - writer.WriteValue(this.managedSpecifier); + writer.WriteValue(this.managedOrUnmanagedKeyword); writer.WriteValue(this.unmanagedCallingConventionList); } @@ -33375,7 +33375,7 @@ public override CSharpSyntaxNode VisitFunctionPointerParameterList(FunctionPoint => node.Update((SyntaxToken)Visit(node.LessThanToken), VisitList(node.Parameters), (SyntaxToken)Visit(node.GreaterThanToken)); public override CSharpSyntaxNode VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update((SyntaxToken)Visit(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionListSyntax)Visit(node.UnmanagedCallingConventionList)); + => node.Update((SyntaxToken)Visit(node.ManagedOrUnmanagedKeyword), (FunctionPointerUnmanagedCallingConventionListSyntax)Visit(node.UnmanagedCallingConventionList)); public override CSharpSyntaxNode VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => node.Update((SyntaxToken)Visit(node.OpenBracketToken), VisitList(node.CallingConventions), (SyntaxToken)Visit(node.CloseBracketToken)); @@ -34287,23 +34287,23 @@ public FunctionPointerParameterListSyntax FunctionPointerParameterList(SyntaxTok return result; } - public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { #if DEBUG - if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); - switch (managedSpecifier.Kind) + if (managedOrUnmanagedKeyword == null) throw new ArgumentNullException(nameof(managedOrUnmanagedKeyword)); + switch (managedOrUnmanagedKeyword.Kind) { case SyntaxKind.ManagedKeyword: case SyntaxKind.UnmanagedKeyword: break; - default: throw new ArgumentException(nameof(managedSpecifier)); + default: throw new ArgumentException(nameof(managedOrUnmanagedKeyword)); } #endif int hash; - var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, this.context, out hash); + var cached = CSharpSyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList, this.context, out hash); if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; - var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, this.context); + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList, this.context); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); @@ -39162,23 +39162,23 @@ public static FunctionPointerParameterListSyntax FunctionPointerParameterList(Sy return result; } - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { #if DEBUG - if (managedSpecifier == null) throw new ArgumentNullException(nameof(managedSpecifier)); - switch (managedSpecifier.Kind) + if (managedOrUnmanagedKeyword == null) throw new ArgumentNullException(nameof(managedOrUnmanagedKeyword)); + switch (managedOrUnmanagedKeyword.Kind) { case SyntaxKind.ManagedKeyword: case SyntaxKind.UnmanagedKeyword: break; - default: throw new ArgumentException(nameof(managedSpecifier)); + default: throw new ArgumentException(nameof(managedOrUnmanagedKeyword)); } #endif int hash; - var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList, out hash); + var cached = SyntaxNodeCache.TryGetNode((int)SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList, out hash); if (cached != null) return (FunctionPointerCallingConventionSyntax)cached; - var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedSpecifier, unmanagedCallingConventionList); + var result = new FunctionPointerCallingConventionSyntax(SyntaxKind.FunctionPointerCallingConvention, managedOrUnmanagedKeyword, unmanagedCallingConventionList); if (hash >= 0) { SyntaxNodeCache.AddNode(result, hash); diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs index b96b17d85787a..524a716e31097 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Main.Generated.cs @@ -1665,7 +1665,7 @@ public partial class CSharpSyntaxRewriter : CSharpSyntaxVisitor => node.Update(VisitToken(node.LessThanToken), VisitList(node.Parameters), VisitToken(node.GreaterThanToken)); public override SyntaxNode? VisitFunctionPointerCallingConvention(FunctionPointerCallingConventionSyntax node) - => node.Update(VisitToken(node.ManagedSpecifier), (FunctionPointerUnmanagedCallingConventionListSyntax?)Visit(node.UnmanagedCallingConventionList)); + => node.Update(VisitToken(node.ManagedOrUnmanagedKeyword), (FunctionPointerUnmanagedCallingConventionListSyntax?)Visit(node.UnmanagedCallingConventionList)); public override SyntaxNode? VisitFunctionPointerUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax node) => node.Update(VisitToken(node.OpenBracketToken), VisitList(node.CallingConventions), VisitToken(node.CloseBracketToken)); @@ -2485,20 +2485,20 @@ public static FunctionPointerParameterListSyntax FunctionPointerParameterList(Se => SyntaxFactory.FunctionPointerParameterList(SyntaxFactory.Token(SyntaxKind.LessThanToken), parameters, SyntaxFactory.Token(SyntaxKind.GreaterThanToken)); /// Creates a new FunctionPointerCallingConventionSyntax instance. - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { - switch (managedSpecifier.Kind()) + switch (managedOrUnmanagedKeyword.Kind()) { case SyntaxKind.ManagedKeyword: case SyntaxKind.UnmanagedKeyword: break; - default: throw new ArgumentException(nameof(managedSpecifier)); + default: throw new ArgumentException(nameof(managedOrUnmanagedKeyword)); } - return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedSpecifier.Node!, unmanagedCallingConventionList == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)unmanagedCallingConventionList.Green).CreateRed(); + return (FunctionPointerCallingConventionSyntax)Syntax.InternalSyntax.SyntaxFactory.FunctionPointerCallingConvention((Syntax.InternalSyntax.SyntaxToken)managedOrUnmanagedKeyword.Node!, unmanagedCallingConventionList == null ? null : (Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionListSyntax)unmanagedCallingConventionList.Green).CreateRed(); } /// Creates a new FunctionPointerCallingConventionSyntax instance. - public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedSpecifier) - => SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, default); + public static FunctionPointerCallingConventionSyntax FunctionPointerCallingConvention(SyntaxToken managedOrUnmanagedKeyword) + => SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, default); /// Creates a new FunctionPointerUnmanagedCallingConventionListSyntax instance. public static FunctionPointerUnmanagedCallingConventionListSyntax FunctionPointerUnmanagedCallingConventionList(SyntaxToken openBracketToken, SeparatedSyntaxList callingConventions, SyntaxToken closeBracketToken) diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index 6df767da3a856..73c303cc5b833 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -591,7 +591,7 @@ internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode } /// SyntaxToken representing whether the calling convention is managed or unmanaged. - public SyntaxToken ManagedSpecifier => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)this.Green).managedSpecifier, Position, 0); + public SyntaxToken ManagedOrUnmanagedKeyword => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerCallingConventionSyntax)this.Green).managedOrUnmanagedKeyword, Position, 0); /// Optional list of identifiers that will contribute to an unmanaged calling convention. public FunctionPointerUnmanagedCallingConventionListSyntax? UnmanagedCallingConventionList => GetRed(ref this.unmanagedCallingConventionList, 1); @@ -604,11 +604,11 @@ internal FunctionPointerCallingConventionSyntax(InternalSyntax.CSharpSyntaxNode [return: MaybeNull] public override TResult Accept(CSharpSyntaxVisitor visitor) => visitor.VisitFunctionPointerCallingConvention(this); - public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifier, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) + public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedOrUnmanagedKeyword, FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) { - if (managedSpecifier != this.ManagedSpecifier || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) + if (managedOrUnmanagedKeyword != this.ManagedOrUnmanagedKeyword || unmanagedCallingConventionList != this.UnmanagedCallingConventionList) { - var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedSpecifier, unmanagedCallingConventionList); + var newNode = SyntaxFactory.FunctionPointerCallingConvention(managedOrUnmanagedKeyword, unmanagedCallingConventionList); var annotations = GetAnnotations(); return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; } @@ -616,8 +616,8 @@ public FunctionPointerCallingConventionSyntax Update(SyntaxToken managedSpecifie return this; } - public FunctionPointerCallingConventionSyntax WithManagedSpecifier(SyntaxToken managedSpecifier) => Update(managedSpecifier, this.UnmanagedCallingConventionList); - public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) => Update(this.ManagedSpecifier, unmanagedCallingConventionList); + public FunctionPointerCallingConventionSyntax WithManagedOrUnmanagedKeyword(SyntaxToken managedOrUnmanagedKeyword) => Update(managedOrUnmanagedKeyword, this.UnmanagedCallingConventionList); + public FunctionPointerCallingConventionSyntax WithUnmanagedCallingConventionList(FunctionPointerUnmanagedCallingConventionListSyntax? unmanagedCallingConventionList) => Update(this.ManagedOrUnmanagedKeyword, unmanagedCallingConventionList); public FunctionPointerCallingConventionSyntax AddUnmanagedCallingConventionListCallingConventions(params FunctionPointerUnmanagedCallingConventionSyntax[] items) { diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs index 8364ba52c54ce..22031441ac5b1 100644 --- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs +++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs @@ -6427,7 +6427,7 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) { while (true) { - lastTokenOfType = EatToken(SyntaxKind.IdentifierToken); + lastTokenOfType = TryEatToken(SyntaxKind.IdentifierToken) ?? lastTokenOfType; if (skipBadFunctionPointerTokens() == PostSkipAction.Abort) { @@ -6438,7 +6438,7 @@ private ScanTypeFlags ScanFunctionPointerType(out SyntaxToken lastTokenOfType) lastTokenOfType = EatToken(); } - lastTokenOfType = EatToken(SyntaxKind.CloseBracketToken); + lastTokenOfType = TryEatToken(SyntaxKind.CloseBracketToken) ?? lastTokenOfType; } finally { diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index a7ffd498f57f8..25db015bfd859 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -9,7 +9,7 @@ Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithModifiers(Microsoft Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax.WithType(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.BaseParameterSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedSpecifier.get -> Microsoft.CodeAnalysis.SyntaxToken +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedOrUnmanagedKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedSpecifier(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs index 199036e8cc671..70c55fd602f61 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs @@ -97,32 +97,63 @@ public static FunctionPointerMethodSymbol CreateFromSource(FunctionPointerTypeSy // PROTOTYPE(func-ptr): Do this right. Just making compatible changes for now static CallingConvention getCallingConvention(FunctionPointerCallingConventionSyntax? callingConventionSyntax, DiagnosticBag diagnostics) { - switch (callingConventionSyntax) + switch (callingConventionSyntax?.ManagedOrUnmanagedKeyword.Kind()) { case null: return CallingConvention.Default; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.ManagedKeyword } }: - Debug.Assert(callingConventionSyntax.UnmanagedCallingConventionList is null || callingConventionSyntax.ContainsDiagnostics); - return CallingConvention.Default; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Cdecl"): - return CallingConvention.CDecl; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Thiscall"): - return CallingConvention.ThisCall; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Fastcall"): - return CallingConvention.FastCall; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: { } specifiers } when isCallingConvention(specifiers, "Stdcall"): - return CallingConvention.Standard; - case { ManagedSpecifier: { RawKind: (int)SyntaxKind.UnmanagedKeyword }, UnmanagedCallingConventionList: null }: - return CallingConvention.Unmanaged; - - default: - // PROTOTYPE(func-ptr): Handle the possible null and actually construct the correct convention - diagnostics.Add(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, callingConventionSyntax.GetLocation(), callingConventionSyntax.UnmanagedCallingConventionList!.CallingConventions[0].Name.Text); + + case SyntaxKind.ManagedKeyword: + // Possible if we get a node not constructed by the parser + if (callingConventionSyntax.UnmanagedCallingConventionList is object && !callingConventionSyntax.ContainsDiagnostics) + { + diagnostics.Add(ErrorCode.ERR_CannotSpecifyManagedWithUnmanagedSpecifiers, callingConventionSyntax.UnmanagedCallingConventionList.GetLocation()); + } return CallingConvention.Default; + + case SyntaxKind.UnmanagedKeyword: + switch (callingConventionSyntax.UnmanagedCallingConventionList) + { + case null: + return CallingConvention.Unmanaged; + + case { CallingConventions: { Count: 1 } specifiers }: + return specifiers[0].Name switch + { + { Text: "Cdecl" } => CallingConvention.CDecl, + { Text: "Stdcall" } => CallingConvention.Standard, + { Text: "Thiscall" } => CallingConvention.ThisCall, + { Text: "Fastcall" } => CallingConvention.FastCall, + // PROTOTYPE(func-ptr): Handle unrecognized specifiers + var name => reportBadConventionAndReturn(name.Text, name, diagnostics) + }; + + case { CallingConventions: { Count: 0 } } unmanagedList: + // Should never be possible from parser-constructed code (parser will always provide at least a missing identifier token), + // so diagnostic quality isn't hugely important + return reportBadConventionAndReturn(givenConvention: "", unmanagedList, diagnostics); + + case { CallingConventions: var specifiers }: + // PROTOTYPE(func-ptr): Handle multiple specifiers + foreach (var convention in specifiers) + { + _ = reportBadConventionAndReturn(convention.Name.Text, convention.Name, diagnostics); + } + + return CallingConvention.Default; + } + + case var unexpected: + throw ExceptionUtilities.UnexpectedValue(unexpected); } - static bool isCallingConvention(FunctionPointerUnmanagedCallingConventionListSyntax specifiers, string expected) - => specifiers.CallingConventions[0].Name.Text == expected; + static CallingConvention reportBadConventionAndReturn(string givenConvention, SyntaxNodeOrToken node, DiagnosticBag diagnostics) + { + if (!node.ContainsDiagnostics) + { + diagnostics.Add(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, node.GetLocation(), givenConvention); + } + return CallingConvention.Default; + } } } diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs index b039b34a29b07..e9d390604ff5f 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs @@ -134,16 +134,6 @@ private static ImmutableArray MakeParameters lastIndex) break; - if (mustBeLastParameter == null) - { - if (parameterSyntax is ParameterSyntax concreteParam && - (concreteParam.Modifiers.Any(SyntaxKind.ParamsKeyword) || - concreteParam.Identifier.Kind() == SyntaxKind.ArgListKeyword)) - { - mustBeLastParameter = concreteParam; - } - } - CheckParameterModifiers(parameterSyntax, diagnostics, parsingFunctionPointer); var refKind = GetModifiers(parameterSyntax.Modifiers, out SyntaxToken refnessKeyword, out SyntaxToken paramsKeyword, out SyntaxToken thisKeyword); @@ -152,25 +142,35 @@ private static ImmutableArray MakeParametersFunction pointer calling convention syntax. - + diff --git a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs index c072df93fee02..5c7017b6956bb 100644 --- a/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs +++ b/src/Compilers/CSharp/Portable/Syntax/SyntaxKind.cs @@ -212,6 +212,7 @@ public enum SyntaxKind : ushort /// /// /// + /// // keywords with an enum value less than ElifKeyword are considered i.a. contextual keywords // additional preprocessor keywords diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf index ca6a02304e7f6..58a397222af8b 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.cs.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Pokud chcete odstranit toto varování, můžete místo toho použít /reference - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf index d5378cec8b88e..06fe7231db34b 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.de.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Um die Warnung zu beheben, können Sie stattdessen /reference verwenden (Einbett - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf index ff1d2404198f5..295ae6bfd5094 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.es.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Para eliminar la advertencia puede usar /reference (establezca la propiedad Embe - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf index 0f5c0b95e9b6f..ea474cd6cf601 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.fr.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Pour supprimer l'avertissement, vous pouvez utiliser la commande /reference (dé - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf index 0d135066c13f2..db6e18b78a9a5 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.it.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Per rimuovere l'avviso, è invece possibile usare /reference (impostare la propr - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf index 9225d060c4a60..6b27180dc5781 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ja.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf index 5e9390070f877..b0fc5d05d50eb 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ko.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf index a442aa9624d3b..2287778aad201 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pl.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Aby usunąć ostrzeżenie, możesz zamiast tego użyć opcji /reference (ustaw w - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf index 0b258fff1ab9d..001163da21046 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.pt-BR.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10350,4 +10350,4 @@ Para incorporar informações de tipo de interoperabilidade para os dois assembl - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf index c063f96744329..00912899705ff 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.ru.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf index d9ae8c74e0fa1..24d4d753569fe 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.tr.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ Uyarıyı kaldırmak için, /reference kullanabilirsiniz (Birlikte Çalışma T - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf index 97ac55d6baf75..844b08e8e20c7 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hans.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf index e2729a87b7cdf..f9d9290ccbcf7 100644 --- a/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf +++ b/src/Compilers/CSharp/Portable/xlf/CSharpResources.zh-Hant.xlf @@ -433,8 +433,8 @@ - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - '{0}' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + '{0}' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. @@ -10352,4 +10352,4 @@ To remove the warning, you can use /reference instead (set the Embed Interop Typ - \ No newline at end of file + diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs index ceaf2f37c44bc..831e18b5b2bba 100644 --- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs +++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs @@ -92,6 +92,35 @@ void symbolValidator(ModuleSymbol module) } } + [Fact] + public void MultipleCallingConventions() + { + var comp = CreateCompilationWithFunctionPointers(@" +#pragma warning disable CS0168 +unsafe class C +{ + public void M() + { + delegate* unmanaged[Thiscall, Stdcall] ptr; + } +}"); + + // PROTOTYPE(func-ptr): Should pass, verify emit and readback + comp.VerifyDiagnostics( + // (7,29): error CS8807: 'Thiscall' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + // delegate* unmanaged[Thiscall, Stdcall] ptr; + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "Thiscall").WithArguments("Thiscall").WithLocation(7, 29), + // (7,39): error CS8807: 'Stdcall' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + // delegate* unmanaged[Thiscall, Stdcall] ptr; + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "Stdcall").WithArguments("Stdcall").WithLocation(7, 39) + ); + } + + [Fact] + public void UnrecognizedCallingConventions() + { + } + [Fact] public void RefParameters() { diff --git a/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs b/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs index 2bff51c27e8b6..6738c1303f950 100644 --- a/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs +++ b/src/Compilers/CSharp/Test/Symbol/Symbols/FunctionPointerTypeSymbolTests.cs @@ -262,25 +262,39 @@ public void InvalidCallingConventions() var comp = CreateFunctionPointerCompilation(@" class C { - public unsafe void M(delegate* unmanaged[invalid] p) {} + public unsafe void M1(delegate* unmanaged[invalid] p) {} + public unsafe void M2(delegate* unmanaged[invalid, Stdcall] p) {} + public unsafe void M3(delegate* unmanaged[] p) {} }"); + comp.VerifyDiagnostics( - // (4,36): error CS8807: 'invalid' is not a valid calling convention for a function pointer. Valid conventions are 'cdecl', 'managed', 'thiscall', and 'stdcall'. - // public unsafe void M(delegate* unmanaged[invalid] p) {} - Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "unmanaged[invalid]").WithArguments("invalid").WithLocation(4, 36)); + // (4,47): error CS8807: 'invalid' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + // public unsafe void M1(delegate* unmanaged[invalid] p) {} + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "invalid").WithArguments("invalid").WithLocation(4, 47), + // (5,47): error CS8807: 'invalid' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + // public unsafe void M2(delegate* unmanaged[invalid, Stdcall] p) {} + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "invalid").WithArguments("invalid").WithLocation(5, 47), + // (5,56): error CS8807: 'Stdcall' is not a valid calling convention specifier for a function pointer. Valid conventions are 'Cdecl', 'Stdcall', 'Thiscall', and 'Fastcall'. + // public unsafe void M2(delegate* unmanaged[invalid, Stdcall] p) {} + Diagnostic(ErrorCode.ERR_InvalidFunctionPointerCallingConvention, "Stdcall").WithArguments("Stdcall").WithLocation(5, 56), + // (6,47): error CS1001: Identifier expected + // public unsafe void M3(delegate* unmanaged[] p) {} + Diagnostic(ErrorCode.ERR_IdentifierExpected, "]").WithLocation(6, 47)); var c = comp.GetTypeByMetadataName("C"); - var m = c.GetMethod("M"); + var m = c.GetMethod("M1"); var pointerType = (FunctionPointerTypeSymbol)m.Parameters.Single().Type; FunctionPointerUtilities.CommonVerifyFunctionPointer(pointerType); Assert.Equal(CallingConvention.Default, pointerType.Signature.CallingConvention); + // PROTOTYPE(func-ptr): Verify the public results of M2 and M3 + // https://github.com/dotnet/roslyn/issues/43321 test public calling convention exposure when added to the API var syntaxTree = comp.SyntaxTrees[0]; var model = comp.GetSemanticModel(syntaxTree); FunctionPointerUtilities.VerifyFunctionPointerSemanticInfo(model, - syntaxTree.GetRoot().DescendantNodes().OfType().Single(), + syntaxTree.GetRoot().DescendantNodes().OfType().First(), expectedSyntax: "delegate* unmanaged[invalid]", expectedType: "delegate*", expectedSymbol: "delegate*"); diff --git a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs index 16fb39d0c4d2d..7443809d418eb 100644 --- a/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs +++ b/src/Compilers/CSharp/Test/Syntax/Generated/Syntax.Test.xml.Generated.cs @@ -833,7 +833,7 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() { var node = GenerateFunctionPointerCallingConvention(); - Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind); + Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedOrUnmanagedKeyword.Kind); Assert.Null(node.UnmanagedCallingConventionList); AttachAndCheckDiagnostics(node); @@ -10457,9 +10457,9 @@ public void TestFunctionPointerCallingConventionFactoryAndProperties() { var node = GenerateFunctionPointerCallingConvention(); - Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedSpecifier.Kind()); + Assert.Equal(SyntaxKind.ManagedKeyword, node.ManagedOrUnmanagedKeyword.Kind()); Assert.Null(node.UnmanagedCallingConventionList); - var newNode = node.WithManagedSpecifier(node.ManagedSpecifier).WithUnmanagedCallingConventionList(node.UnmanagedCallingConventionList); + var newNode = node.WithManagedOrUnmanagedKeyword(node.ManagedOrUnmanagedKeyword).WithUnmanagedCallingConventionList(node.UnmanagedCallingConventionList); Assert.Equal(node, newNode); } From 8323e8f25d699ab791bb0d17417699487b917a5c Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Wed, 8 Jul 2020 16:32:24 -0700 Subject: [PATCH 10/13] Update public api --- src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt index 25db015bfd859..e485d0f9c3c15 100644 --- a/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt +++ b/src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt @@ -11,8 +11,8 @@ Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.AddUnmanagedCallingConventionListCallingConventions(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.ManagedOrUnmanagedKeyword.get -> Microsoft.CodeAnalysis.SyntaxToken Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.UnmanagedCallingConventionList.get -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedSpecifier(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.Update(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithManagedOrUnmanagedKeyword(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax.WithUnmanagedCallingConventionList(Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax.AddParameters(params Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax @@ -147,8 +147,8 @@ override Microsoft.CodeAnalysis.CSharp.Syntax.RecordDeclarationSyntax.TypeParame static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSpeculativeSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer) -> Microsoft.CodeAnalysis.SymbolInfo static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.GetSymbolInfo(this Microsoft.CodeAnalysis.SemanticModel semanticModel, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, System.Threading.CancellationToken cancellationToken = default(System.Threading.CancellationToken)) -> Microsoft.CodeAnalysis.SymbolInfo static Microsoft.CodeAnalysis.CSharp.CSharpExtensions.TryGetSpeculativeSemanticModel(this Microsoft.CodeAnalysis.SemanticModel semanticModel, int position, Microsoft.CodeAnalysis.CSharp.Syntax.PrimaryConstructorBaseTypeSyntax constructorInitializer, out Microsoft.CodeAnalysis.SemanticModel speculativeModel) -> bool -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax -static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedSpecifier, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax +static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerCallingConvention(Microsoft.CodeAnalysis.SyntaxToken managedOrUnmanagedKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerUnmanagedCallingConventionListSyntax unmanagedCallingConventionList) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerCallingConventionSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameter(Microsoft.CodeAnalysis.SyntaxList attributeLists, Microsoft.CodeAnalysis.SyntaxTokenList modifiers, Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax type) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterSyntax static Microsoft.CodeAnalysis.CSharp.SyntaxFactory.FunctionPointerParameterList(Microsoft.CodeAnalysis.SeparatedSyntaxList parameters = default(Microsoft.CodeAnalysis.SeparatedSyntaxList)) -> Microsoft.CodeAnalysis.CSharp.Syntax.FunctionPointerParameterListSyntax From 35e1f77314639bd62998e378d5b59f1923d49ca4 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Thu, 9 Jul 2020 12:02:50 -0700 Subject: [PATCH 11/13] Use ValueText to handle escaped identifiers and add tests. --- .../FunctionPointers/FunctionPointerMethodSymbol.cs | 8 ++++---- .../Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs | 9 ++++----- 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs index 70c55fd602f61..e9ff0607ef462 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs @@ -119,10 +119,10 @@ static CallingConvention getCallingConvention(FunctionPointerCallingConventionSy case { CallingConventions: { Count: 1 } specifiers }: return specifiers[0].Name switch { - { Text: "Cdecl" } => CallingConvention.CDecl, - { Text: "Stdcall" } => CallingConvention.Standard, - { Text: "Thiscall" } => CallingConvention.ThisCall, - { Text: "Fastcall" } => CallingConvention.FastCall, + { ValueText: "Cdecl" } => CallingConvention.CDecl, + { ValueText: "Stdcall" } => CallingConvention.Standard, + { ValueText: "Thiscall" } => CallingConvention.ThisCall, + { ValueText: "Fastcall" } => CallingConvention.FastCall, // PROTOTYPE(func-ptr): Handle unrecognized specifiers var name => reportBadConventionAndReturn(name.Text, name, diagnostics) }; diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs index 831e18b5b2bba..f7877b29af92c 100644 --- a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs +++ b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs @@ -68,6 +68,10 @@ private CSharpCompilation CreateCompilationWithFunctionPointersAndIl(string sour [InlineData("unmanaged[Thiscall]", CallingConvention.ThisCall)] [InlineData("unmanaged[Stdcall]", CallingConvention.Standard)] [InlineData("unmanaged[Fastcall]", CallingConvention.FastCall)] + [InlineData("unmanaged[@Cdecl]", CallingConvention.CDecl)] + [InlineData("unmanaged[@Thiscall]", CallingConvention.ThisCall)] + [InlineData("unmanaged[@Stdcall]", CallingConvention.Standard)] + [InlineData("unmanaged[@Fastcall]", CallingConvention.FastCall)] // PROTOTYPE(func-ptr): Update SRM so it can decode the convention correctly //[InlineData("unmanaged", CallingConvention.Unmanaged)] internal void CallingConventions(string conventionString, CallingConvention expectedConvention) @@ -116,11 +120,6 @@ public void M() ); } - [Fact] - public void UnrecognizedCallingConventions() - { - } - [Fact] public void RefParameters() { From c3dc3358a10249f336aad210b144189192ab4bd1 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Thu, 9 Jul 2020 15:12:15 -0700 Subject: [PATCH 12/13] Use ValueText in a couple more places. --- .../Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs index e9ff0607ef462..30391dd40b31b 100644 --- a/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs +++ b/src/Compilers/CSharp/Portable/Symbols/FunctionPointers/FunctionPointerMethodSymbol.cs @@ -124,7 +124,7 @@ static CallingConvention getCallingConvention(FunctionPointerCallingConventionSy { ValueText: "Thiscall" } => CallingConvention.ThisCall, { ValueText: "Fastcall" } => CallingConvention.FastCall, // PROTOTYPE(func-ptr): Handle unrecognized specifiers - var name => reportBadConventionAndReturn(name.Text, name, diagnostics) + var name => reportBadConventionAndReturn(name.ValueText, name, diagnostics) }; case { CallingConventions: { Count: 0 } } unmanagedList: @@ -136,7 +136,7 @@ static CallingConvention getCallingConvention(FunctionPointerCallingConventionSy // PROTOTYPE(func-ptr): Handle multiple specifiers foreach (var convention in specifiers) { - _ = reportBadConventionAndReturn(convention.Name.Text, convention.Name, diagnostics); + _ = reportBadConventionAndReturn(convention.Name.ValueText, convention.Name, diagnostics); } return CallingConvention.Default; From 6117cadb502da619da5fab81e9aab1e9ee725cf5 Mon Sep 17 00:00:00 2001 From: Fredric Silberberg Date: Fri, 10 Jul 2020 14:49:05 -0700 Subject: [PATCH 13/13] PR Feeback: * Enable tests as appropriate * Fix doc comments * Remove unnecessary generic parameters. --- .../Portable/Generated/Syntax.xml.Internal.Generated.cs | 4 ++-- .../Portable/Generated/Syntax.xml.Syntax.Generated.cs | 4 ++-- .../CSharp/Portable/Symbols/Source/ParameterHelpers.cs | 8 +++----- src/Compilers/CSharp/Portable/Syntax/Syntax.xml | 4 ++-- .../Formatting/FormattingTests_FunctionPointers.cs | 8 ++++---- 5 files changed, 13 insertions(+), 15 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs index 1acd08d47dff9..8533d9b56b691 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Internal.Generated.cs @@ -1112,7 +1112,7 @@ internal FunctionPointerTypeSyntax(SyntaxKind kind, SyntaxToken delegateKeyword, public SyntaxToken DelegateKeyword => this.delegateKeyword; /// SyntaxToken representing the asterisk. public SyntaxToken AsteriskToken => this.asteriskToken; - /// SyntaxToken representing the optional calling convention. + /// Node representing the optional calling convention. public FunctionPointerCallingConventionSyntax? CallingConvention => this.callingConvention; /// List of the parameter types and return type of the function pointer. public FunctionPointerParameterListSyntax ParameterList => this.parameterList; @@ -1594,7 +1594,7 @@ internal FunctionPointerUnmanagedCallingConventionSyntax(SyntaxKind kind, Syntax this.name = name; } - /// SyntaxToken the calling convention identifier. + /// SyntaxToken representing the calling convention identifier. public SyntaxToken Name => this.name; internal override GreenNode? GetSlot(int index) diff --git a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs index 73c303cc5b833..5cf9f0e5e77ec 100644 --- a/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compilers/CSharp/Portable/Generated/Syntax.xml.Syntax.Generated.cs @@ -481,7 +481,7 @@ internal FunctionPointerTypeSyntax(InternalSyntax.CSharpSyntaxNode green, Syntax /// SyntaxToken representing the asterisk. public SyntaxToken AsteriskToken => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerTypeSyntax)this.Green).asteriskToken, GetChildPosition(1), GetChildIndex(1)); - /// SyntaxToken representing the optional calling convention. + /// Node representing the optional calling convention. public FunctionPointerCallingConventionSyntax? CallingConvention => GetRed(ref this.callingConvention, 2); /// List of the parameter types and return type of the function pointer. @@ -687,7 +687,7 @@ internal FunctionPointerUnmanagedCallingConventionSyntax(InternalSyntax.CSharpSy { } - /// SyntaxToken the calling convention identifier. + /// SyntaxToken representing the calling convention identifier. public SyntaxToken Name => new SyntaxToken(this, ((Syntax.InternalSyntax.FunctionPointerUnmanagedCallingConventionSyntax)this.Green).name, Position, 0); internal override SyntaxNode? GetNodeSlot(int index) => null; diff --git a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs index e9d390604ff5f..8ee23fb66a0fd 100644 --- a/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs +++ b/src/Compilers/CSharp/Portable/Symbols/Source/ParameterHelpers.cs @@ -279,8 +279,7 @@ internal static void EnsureNullableAttributeExists(CSharpCompilation compilation private static Location GetParameterLocation(ParameterSymbol parameter) => parameter.GetNonNullSyntaxNode().Location; - private static void CheckParameterModifiers( - TParameterSyntax parameter, DiagnosticBag diagnostics, bool parsingFunctionPointerParams) where TParameterSyntax : BaseParameterSyntax + private static void CheckParameterModifiers(BaseParameterSyntax parameter, DiagnosticBag diagnostics, bool parsingFunctionPointerParams) { var seenThis = false; var seenRef = false; @@ -422,15 +421,14 @@ private static void CheckParameterModifiers( } } - private static void ReportParameterErrors( + private static void ReportParameterErrors( Symbol owner, - TParameterSyntax parameterSyntax, + BaseParameterSyntax parameterSyntax, ParameterSymbol parameter, SyntaxToken thisKeyword, SyntaxToken paramsKeyword, int firstDefault, DiagnosticBag diagnostics) - where TParameterSyntax : BaseParameterSyntax { int parameterIndex = parameter.Ordinal; bool isDefault = parameterSyntax is ParameterSyntax { Default: { } }; diff --git a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml index bff2b2c465ed3..d1dbc90a0a427 100644 --- a/src/Compilers/CSharp/Portable/Syntax/Syntax.xml +++ b/src/Compilers/CSharp/Portable/Syntax/Syntax.xml @@ -239,7 +239,7 @@ - SyntaxToken representing the optional calling convention. + Node representing the optional calling convention. @@ -320,7 +320,7 @@ - SyntaxToken the calling convention identifier. + SyntaxToken representing the calling convention identifier. diff --git a/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs b/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs index 33ded2689ab02..cb5e379d89d31 100644 --- a/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs +++ b/src/Workspaces/CSharpTest/Formatting/FormattingTests_FunctionPointers.cs @@ -83,7 +83,7 @@ unsafe class C await AssertFormatAsync(expected, content); } - [Fact(Skip = "PROTOTYPE(func-ptr): Even though the rule is returning put a space, it's getting ignored, resulting in delegate*invalid <")] + [Fact] public async Task FormatFunctionPointerWithUnrecognizedCallingConvention() { var content = @" @@ -95,13 +95,13 @@ unsafe class C var expected = @" unsafe class C { - delegate* invalid functionPointer; + delegate*invalid functionPointer; }"; await AssertFormatAsync(expected, content); } - [Fact(Skip = "PROTOTYPE(func-ptr): Even though the rule is returning put a space, it's getting ignored, resulting in delegate*invalid [")] + [Fact] public async Task FormatFunctionPointerWithInvalidCallingConventionAndSpecifiers() { var content = @" @@ -113,7 +113,7 @@ unsafe class C var expected = @" unsafe class C { - delegate* invalid[Cdecl, Thiscall] functionPointer; + delegate*invalid [Cdecl, Thiscall] functionPointer; }"; await AssertFormatAsync(expected, content);