Generate friendly syntax for nint/nuint

src/Analyzers/CSharp/Tests/UseImplicitOrExplicitType/UseExplicitTypeTests.cs

@@ -362,6 +362,62 @@ void Method(int? x)
             await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeExceptWhereApparent());
         }
 
+#if !CODE_STYLE // TODO: Skipped tests in CodeStyle layer depend on new compiler API (IsNativeIntegerType) that is not available in CodeStyle layer.
+        // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExplicitType)]
+        [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+        public async Task InNativeIntIntrinsicType()
+        {
+            var before = @"
+class Program
+{
+    void Method(nint x)
+    {
+        [|var|] y = x;
+    }
+}";
+            var after = @"
+class Program
+{
+    void Method(nint x)
+    {
+        nint y = x;
+    }
+}";
+            // The type is intrinsic and not apparent
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeEverywhere());
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeForBuiltInTypesOnly());
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeExceptWhereApparent());
+        }
+
+        [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExplicitType)]
+        [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+        public async Task InNativeUnsignedIntIntrinsicType()
+        {
+            var before = @"
+class Program
+{
+    void Method(nuint x)
+    {
+        [|var|] y = x;
+    }
+}";
+            var after = @"
+class Program
+{
+    void Method(nuint x)
+    {
+        nuint y = x;
+    }
+}";
+            // The type is intrinsic and not apparent
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeEverywhere());
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeForBuiltInTypesOnly());
+            await TestInRegularAndScriptAsync(before, after, options: ExplicitTypeExceptWhereApparent());
+        }
+#endif
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsUseExplicitType)]
         [WorkItem(27221, "https://github.com/dotnet/roslyn/issues/27221")]
         public async Task WithRefIntrinsicType()

src/Compilers/CSharp/Portable/PublicAPI.Unshipped.txt

@@ -82,6 +82,8 @@ Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddAttributeLists(params
 Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken tryKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block, Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.CatchClauseSyntax> catches, Microsoft.CodeAnalysis.CSharp.Syntax.FinallyClauseSyntax finally) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax.WithAttributeLists(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists) -> Microsoft.CodeAnalysis.CSharp.Syntax.TryStatementSyntax
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsNint.get -> bool
+Microsoft.CodeAnalysis.CSharp.Syntax.TypeSyntax.IsNuint.get -> bool
 Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.AddBlockAttributeLists(params Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax[] items) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax
 Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax.Update(Microsoft.CodeAnalysis.SyntaxList<Microsoft.CodeAnalysis.CSharp.Syntax.AttributeListSyntax> attributeLists, Microsoft.CodeAnalysis.SyntaxToken unsafeKeyword, Microsoft.CodeAnalysis.CSharp.Syntax.BlockSyntax block) -> Microsoft.CodeAnalysis.CSharp.Syntax.UnsafeStatementSyntax

src/Compilers/CSharp/Portable/Syntax/InternalSyntax/TypeSyntax.cs

@@ -9,6 +9,8 @@ internal abstract partial class TypeSyntax
         public bool IsVar => IsIdentifierName("var");
         public bool IsUnmanaged => IsIdentifierName("unmanaged");
         public bool IsNotNull => IsIdentifierName("notnull");
+        public bool IsNint => IsIdentifierName("nint");
+        public bool IsNuint => IsIdentifierName("nuint");
 
         private bool IsIdentifierName(string id) => this is IdentifierNameSyntax name && name.Identifier.ToString() == id;
     }

src/Compilers/CSharp/Portable/Syntax/TypeSyntax.cs

@@ -11,5 +11,9 @@ public abstract partial class TypeSyntax
         public bool IsUnmanaged => ((InternalSyntax.TypeSyntax)this.Green).IsUnmanaged;
 
         public bool IsNotNull => ((InternalSyntax.TypeSyntax)this.Green).IsNotNull;
+
+        public bool IsNint => ((InternalSyntax.TypeSyntax)this.Green).IsNint;
+
+        public bool IsNuint => ((InternalSyntax.TypeSyntax)this.Green).IsNuint;
     }
 }

src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests.cs

@@ -3885,5 +3885,29 @@ void N()
             Keyword("_"),
             Keyword("_"));
         }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task NativeInteger()
+        {
+            await TestInMethodAsync(
+                code: @"nint i = 0; nuint i2 = 0;",
+                expected: Classifications(Keyword("nint"), Keyword("nuint")));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task NotNativeInteger()
+        {
+            await TestInMethodAsync("nint", "M",
+                code: @"nint i = 0;",
+                expected: Classifications(Class("nint")));
+        }
+
+        [Fact, Trait(Traits.Feature, Traits.Features.Classification)]
+        public async Task NotNativeUnsignedInteger()
+        {
+            await TestInMethodAsync("nuint", "M",
+                code: @"nuint i = 0;",
+                expected: Classifications(Class("nuint")));
+        }
     }
 }

src/EditorFeatures/CSharpTest/Diagnostics/GenerateMethod/GenerateMethodTests.cs

@@ -7517,6 +7517,34 @@ private T First<T>(List<T> list)
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
+        [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+        public async Task MethodWithNativeIntegerTypes()
+        {
+            await TestInRegularAndScriptAsync(
+@"class Class
+{
+    void M(nint i, nuint i2)
+    {
+        (nint, nuint) d = [|NewMethod|](i, i2);
+    }
+}",
+@"using System;
+
+class Class
+{
+    void M(nint i, nuint i2)
+    {
+        (nint, nuint) d = NewMethod(i, i2);
+    }
+
+    private (nint, nuint) NewMethod(nint i, nuint i2)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsGenerateMethod)]
         public async Task MethodWithTuple()
         {

src/EditorFeatures/CSharpTest/ImplementInterface/ImplementInterfaceTests.cs

@@ -149,6 +149,53 @@ public void Method1()
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+        public async Task TestMethodWithNativeIntegers()
+        {
+            var nativeIntegerAttributeDefinition = @"
+namespace System.Runtime.CompilerServices
+{
+    [System.AttributeUsage(AttributeTargets.All)]
+    public sealed class NativeIntegerAttribute : System.Attribute
+    {
+        public NativeIntegerAttribute()
+        {
+        }
+        public NativeIntegerAttribute(bool[] flags)
+        {
+        }
+    }
+}";
+
+            // Note: we're putting the attribute by hand to simulate metadata
+            await TestWithAllCodeStyleOptionsOffAsync(
+@"interface IInterface
+{
+    [return: System.Runtime.CompilerServices.NativeInteger(new[] { true, true })]
+    (nint, nuint) Method(nint x, nuint x2);
+}
+
+class Class : [|IInterface|]
+{
+}" + nativeIntegerAttributeDefinition,
+    @"using System;
+
+interface IInterface
+{
+    [return: System.Runtime.CompilerServices.NativeInteger(new[] { true, true })]
+    (nint, nuint) Method(nint x, nuint x2);
+}
+
+class Class : IInterface
+{
+    public (nint, nuint) Method(nint x, nuint x2)
+    {
+        throw new NotImplementedException();
+    }
+}" + nativeIntegerAttributeDefinition);
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMethodWithTuple()
         {
@@ -235,9 +282,10 @@ public sealed class TupleElementNamesAttribute : Attribute { }
 }
 ";
 
-        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), Test.Utilities.CompilerTrait(Test.Utilities.CompilerFeature.Tuples)]
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface), CompilerTrait(CompilerFeature.Tuples)]
         public async Task TupleWithNamesInMethod()
         {
+            // Note: we're putting the attribute by hand to simulate metadata
             await TestWithAllCodeStyleOptionsOffAsync(
 @"interface IInterface
 {

src/EditorFeatures/Test/MetadataAsSource/MetadataAsSourceTests.CSharp.cs

@@ -31,6 +31,54 @@ I am the very model of a modern major general.
                 Assert.Equal(expectedXMLFragment, extractedXMLFragment);
             }
 
+            [Fact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
+            [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+            public async Task TestNativeInteger()
+            {
+                var metadataSource = "public class C { public nint i; public nuint i2; }";
+                var symbolName = "C";
+
+                await GenerateAndVerifySourceAsync(metadataSource, symbolName, LanguageNames.CSharp, languageVersion: "Preview", metadataLanguageVersion: "Preview",
+                    expected: $@"#region {FeaturesResources.Assembly} ReferencedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
+// {CodeAnalysisResources.InMemoryAssembly}
+#endregion
+
+using System;
+using System.Runtime.CompilerServices;
+
+public class [|C|]
+{{
+    [NativeIntegerAttribute]
+    public nint i;
+    [NativeIntegerAttribute]
+    public nuint i2;
+
+    public C();
+}}");
+            }
+
+            [Fact, Trait(Traits.Feature, Traits.Features.MetadataAsSource)]
+            public async Task TestTupleWithNames()
+            {
+                var metadataSource = "public class C { public (int a, int b) t; }";
+                var symbolName = "C";
+
+                await GenerateAndVerifySourceAsync(metadataSource, symbolName, LanguageNames.CSharp,
+                    expected: $@"#region {FeaturesResources.Assembly} ReferencedAssembly, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null
+// {CodeAnalysisResources.InMemoryAssembly}
+#endregion
+
+using System.Runtime.CompilerServices;
+
+public class [|C|]
+{{
+    [TupleElementNames(new[] {{ ""a"", ""b"" }})]
+    public (int a, int b) t;
+
+    public C();
+}}");
+            }
+
             [Fact, WorkItem(26605, "https://github.com/dotnet/roslyn/issues/26605")]
             public async Task TestValueTuple()
             {

src/Features/Core/Portable/ImplementInterface/AbstractImplementInterfaceService.CodeAction_Property.cs

@@ -73,7 +73,7 @@ private ISymbol GenerateProperty(
             private INamedTypeSymbol[] AttributesToRemove(Compilation compilation)
             {
                 return new[] { compilation.ComAliasNameAttributeType(), compilation.TupleElementNamesAttributeType(),
-                    compilation.DynamicAttributeType() }.WhereNotNull().ToArray()!;
+                    compilation.DynamicAttributeType(), compilation.NativeIntegerAttributeType() }.WhereNotNull().ToArray()!;
             }
 
             private IMethodSymbol? GenerateSetAccessor(

src/Workspaces/CSharp/Portable/Classification/SyntaxClassification/NameSyntaxClassifier.cs

@@ -168,6 +168,15 @@ private bool TryClassifySymbol(
                 }
             }
 
+            if (name.IsNint || name.IsNuint)
+            {
+                if (symbol is ITypeSymbol type && type.IsNativeIntegerType)
+                {
+                    classifiedSpan = new ClassifiedSpan(name.Span, ClassificationTypeNames.Keyword);
+                    return true;
+                }
+            }
+
             if ((name.IsUnmanaged || name.IsNotNull) && name.Parent.IsKind(SyntaxKind.TypeConstraint))
             {
                 var nameToCheck = name.IsUnmanaged ? "unmanaged" : "notnull";

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ICompilationExtensions.cs

@@ -141,6 +141,9 @@ public static ImmutableArray<IAssemblySymbol> GetReferencedAssemblySymbols(this
         public static INamedTypeSymbol? TupleElementNamesAttributeType(this Compilation compilation)
             => compilation.GetTypeByMetadataName(typeof(TupleElementNamesAttribute).FullName!);
 
+        public static INamedTypeSymbol? NativeIntegerAttributeType(this Compilation compilation)
+            => compilation.GetTypeByMetadataName("System.Runtime.CompilerServices.NativeIntegerAttribute");
+
         public static INamedTypeSymbol? DynamicAttributeType(this Compilation compilation)
             => compilation.GetTypeByMetadataName(typeof(DynamicAttribute).FullName!);
 

src/Workspaces/SharedUtilitiesAndExtensions/Compiler/Core/Extensions/ITypeSymbolExtensions.cs

@@ -291,6 +291,11 @@ public static bool IsNumericType([NotNullWhen(returnValue: true)] this ITypeSymb
                     case SpecialType.System_Single:
                     case SpecialType.System_Double:
                     case SpecialType.System_Decimal:
+#if !CODE_STYLE // TODO: Remove the #if once IsNativeIntegerType is available.
+                    // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
+                    case SpecialType.System_IntPtr when type.IsNativeIntegerType:
+                    case SpecialType.System_UIntPtr when type.IsNativeIntegerType:
+#endif
                         return true;
                 }
             }
@@ -393,6 +398,11 @@ public static bool IsSpecialType([NotNullWhen(returnValue: true)] this ITypeSymb
                     case SpecialType.System_UInt16:
                     case SpecialType.System_UInt32:
                     case SpecialType.System_UInt64:
+#if !CODE_STYLE // TODO: Remove the #if once IsNativeIntegerType is available.
+                    // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
+                    case SpecialType.System_IntPtr when symbol.IsNativeIntegerType:
+                    case SpecialType.System_UIntPtr when symbol.IsNativeIntegerType:
+#endif
                         return true;
                 }
             }

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/CSharp/Extensions/ITypeSymbolExtensions.TypeSyntaxGeneratorVisitor.cs

@@ -4,10 +4,10 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Microsoft.CodeAnalysis.FindSymbols.Finders;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Simplification;
@@ -71,6 +71,7 @@ public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol)
                     underlyingType = innerArray.ElementType;
 
 #if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available.
+                    // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
                     if (underlyingType.NullableAnnotation == NullableAnnotation.Annotated)
                     {
                         // If the inner array we just moved to is also nullable, then
@@ -107,6 +108,7 @@ public override TypeSyntax VisitArrayType(IArrayTypeSymbol symbol)
                 TypeSyntax arrayTypeSyntax = SyntaxFactory.ArrayType(elementTypeSyntax, ranks.ToSyntaxList());
 
 #if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available.
+                // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
                 if (symbol.NullableAnnotation == NullableAnnotation.Annotated)
                 {
                     arrayTypeSyntax = SyntaxFactory.NullableType(arrayTypeSyntax);
@@ -188,6 +190,14 @@ private TypeSyntax TryCreateSpecializedNamedTypeSyntax(INamedTypeSymbol symbol)
                     return CreateTupleTypeSyntax(symbol);
                 }
 
+#if !CODE_STYLE // TODO: Remove the #if once IsNativeIntegerType is available.
+                // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
+                if (symbol.IsNativeIntegerType)
+                {
+                    return SyntaxFactory.IdentifierName(symbol.SpecialType == SpecialType.System_IntPtr ? "nint" : "nuint");
+                }
+#endif
+
                 if (symbol.IsNullable())
                 {
                     // Can't have a nullable of a pointer type.  i.e. "int*?" is illegal.
@@ -260,6 +270,7 @@ public override TypeSyntax VisitNamedType(INamedTypeSymbol symbol)
                 }
 
 #if !CODE_STYLE // TODO: Remove the #if once NullableAnnotation is available.
+                // https://github.com/dotnet/roslyn/issues/41462 tracks adding this support
                 if (symbol.NullableAnnotation == NullableAnnotation.Annotated)
                 {
                     typeSyntax = AddInformationTo(SyntaxFactory.NullableType(typeSyntax), symbol);