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/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,35 @@ public void Method1()
 }");
         }
 
+        [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
+        [WorkItem(42986, "https://github.com/dotnet/roslyn/issues/42986")]
+        public async Task TestMethodWithNativeIntegers()
+        {
+            await TestWithAllCodeStyleOptionsOffAsync(
+@"interface IInterface
+{
+    (nint, nuint) Method(nint x, nuint x2);
+}
+
+class Class : [|IInterface|]
+{
+}",
+@"using System;
+
+interface IInterface
+{
+    (nint, nuint) Method(nint x, nuint x2);
+}
+
+class Class : IInterface
+{
+    public (nint, nuint) Method(nint x, nuint x2)
+    {
+        throw new NotImplementedException();
+    }
+}");
+        }
+
         [Fact, Trait(Traits.Feature, Traits.Features.CodeActionsImplementInterface)]
         public async Task TestMethodWithTuple()
         {

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/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);