Expose IsIterator as a public API

src/Compilers/CSharp/Portable/Symbols/Extensions/RewrittenMethodSymbol.cs

@@ -4,7 +4,6 @@
 
 using System.Collections.Immutable;
 using System.Diagnostics;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -59,7 +58,7 @@ internal override TypeWithAnnotations IteratorElementTypeWithAnnotations
             }
         }
 
-        internal override bool IsIterator
+        public override bool IsIterator
         {
             get { return _originalMethod.IsIterator; }
         }

src/Compilers/CSharp/Portable/Symbols/MethodSymbol.cs

@@ -15,7 +15,6 @@
 using Microsoft.CodeAnalysis.CSharp.Emit;
 using Microsoft.CodeAnalysis.PooledObjects;
 using Microsoft.CodeAnalysis.Symbols;
-using Roslyn.Utilities;
 
 namespace Microsoft.CodeAnalysis.CSharp.Symbols
 {
@@ -1085,7 +1084,7 @@ public sealed override bool HasUnsupportedMetadata
 
         #endregion
 
-        internal virtual bool IsIterator
+        public virtual bool IsIterator
         {
             get
             {

src/Compilers/CSharp/Portable/Symbols/PublicModel/MethodSymbol.cs

@@ -328,6 +328,8 @@ INamedTypeSymbol IMethodSymbol.AssociatedAnonymousDelegate
 
         bool IMethodSymbol.IsConditional => _underlying.IsConditional;
 
+        bool IMethodSymbol.IsIterator => _underlying.IsIterator;
+
         DllImportData IMethodSymbol.GetDllImportData() => _underlying.GetDllImportData();
 
         #region ISymbol Members

src/Compilers/CSharp/Portable/Symbols/Source/LocalFunctionOrSourceMemberMethodSymbol.cs

@@ -42,6 +42,6 @@ internal sealed override TypeWithAnnotations IteratorElementTypeWithAnnotations
             }
         }
 
-        internal sealed override bool IsIterator => _lazyIteratorElementType is object;
+        public sealed override bool IsIterator => _lazyIteratorElementType is object;
     }
 }

src/Compilers/CSharp/Test/Semantic/Semantics/IteratorTests.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.CSharp.Symbols;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using System.Linq;
+using Microsoft.CodeAnalysis.CSharp.Symbols.Metadata.PE;
 
 namespace Microsoft.CodeAnalysis.CSharp.UnitTests.Semantics
 {
@@ -61,6 +62,67 @@ IEnumerable<int> I()
             comp.VerifyDiagnostics();
         }
 
+        [Fact]
+        public void BasicIterators_Async()
+        {
+            var source = """
+                using System.Collections.Generic;
+                using System.Threading.Tasks;
+
+                class Test
+                {
+                    async IAsyncEnumerable<int> I()
+                    {
+                        await Task.Yield();
+                        yield return 1;
+                    }
+                }
+                """;
+
+            var comp = CreateCompilation(source, targetFramework: TargetFramework.Net60);
+            comp.VerifyDiagnostics();
+
+            var i = comp.GetMember<MethodSymbol>("Test.I");
+            Assert.True(i.IsIterator);
+            Assert.Equal("System.Int32", i.IteratorElementTypeWithAnnotations.ToTestDisplayString());
+        }
+
+        [Fact]
+        public void BasicIterators_Metadata()
+        {
+            var source = """
+                using System.Collections.Generic;
+                using System.Threading.Tasks;
+
+                public class Test
+                {
+                    public IEnumerable<int> I1()
+                    {
+                        yield return 1;
+                    }
+
+                    public async IAsyncEnumerable<int> I2()
+                    {
+                        await Task.Yield();
+                        yield return 1;
+                    }
+                }
+                """;
+
+            var sourceComp = CreateCompilation(source, targetFramework: TargetFramework.Net60);
+            sourceComp.VerifyDiagnostics();
+
+            var userComp = CreateCompilation("", references: [sourceComp.EmitToImageReference()]);
+            userComp.VerifyEmitDiagnostics();
+            var testType = Assert.IsAssignableFrom<PENamedTypeSymbol>(userComp.GetTypeByMetadataName("Test"));
+
+            var i1 = testType.GetMethod("I1");
+            Assert.False(i1.IsIterator);
+
+            var i2 = testType.GetMethod("I2");
+            Assert.False(i2.IsIterator);
+        }
+
         [Fact]
         public void WrongYieldType()
         {

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

@@ -3,6 +3,7 @@ Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions
 Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions.EmitDifferenceOptions() -> void
 Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions.EmitFieldRva.get -> bool
 Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions.EmitFieldRva.init -> void
+Microsoft.CodeAnalysis.IMethodSymbol.IsIterator.get -> bool
 static readonly Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions.Default -> Microsoft.CodeAnalysis.Emit.EmitDifferenceOptions
 Microsoft.CodeAnalysis.IEventSymbol.IsPartialDefinition.get -> bool
 Microsoft.CodeAnalysis.IEventSymbol.PartialDefinitionPart.get -> Microsoft.CodeAnalysis.IEventSymbol?

src/Compilers/Core/Portable/Symbols/IMethodSymbol.cs

@@ -293,5 +293,10 @@ public interface IMethodSymbol : ISymbol
         /// Returns a flag indicating whether this symbol has at least one applied/inherited conditional attribute.
         /// </summary>
         bool IsConditional { get; }
+
+        /// <summary>
+        /// Returns <see langword="true"/> if this method is a source method implemented as an iterator (either sync or async)
+        /// </summary>
+        bool IsIterator { get; }
     }
 }

src/Compilers/VisualBasic/Portable/Symbols/MethodSymbol.vb

@@ -133,7 +133,7 @@ Namespace Microsoft.CodeAnalysis.VisualBasic.Symbols
         ''' Source: Returns whether this method is an iterator; i.e., does it have the Iterator modifier?
         ''' Metadata: Returns False; methods from metadata cannot be an iterator.
         ''' </summary>
-        Public MustOverride ReadOnly Property IsIterator As Boolean
+        Public MustOverride ReadOnly Property IsIterator As Boolean Implements IMethodSymbol.IsIterator
 
         ''' <summary>
         ''' Indicates whether the accessor is marked with the 'init' modifier.

src/Compilers/VisualBasic/Test/Semantic/Semantics/IteratorTests.vb

@@ -2,14 +2,61 @@
 ' The .NET Foundation licenses this file to you under the MIT license.
 ' See the LICENSE file in the project root for more information.
 
+Imports Microsoft.CodeAnalysis.Test.Utilities
 Imports Microsoft.CodeAnalysis.VisualBasic.Symbols
+Imports Microsoft.CodeAnalysis.VisualBasic.Symbols.Metadata.PE
 Imports Roslyn.Test.Utilities
 
 Namespace Microsoft.CodeAnalysis.VisualBasic.UnitTests.Semantics
 
     Public Class IteratorTests
         Inherits FlowTestBase
 
+        <Fact>
+        Public Sub BasicIterator()
+            Dim compilation = CreateCompilation(
+                    <compilation>
+                        <file name="a.vb">
+                            <![CDATA[
+Imports System.Collections.Generic
+
+Class C
+    Public Iterator Function I As IEnumerable(Of Integer)
+        Yield 1
+    End Function
+End Class
+]]>
+                        </file>
+                    </compilation>).VerifyDiagnostics()
+
+            Dim i = compilation.GetMember(Of MethodSymbol)("C.I")
+            Assert.True(i.IsIterator)
+        End Sub
+
+        <Fact>
+        Public Sub BasicIterator_Metadata()
+            Dim sourceComp = CreateCompilation(
+                    <compilation>
+                        <file name="a.vb">
+                            <![CDATA[
+Imports System.Collections.Generic
+
+Public Class C
+    Public Iterator Function I As IEnumerable(Of Integer)
+        Yield 1
+    End Function
+End Class
+]]>
+                        </file>
+                    </compilation>).VerifyDiagnostics()
+
+            Dim userComp = CreateCompilation("", references:={sourceComp.EmitToImageReference()}).VerifyDiagnostics()
+            Dim cMetadataType = Assert.IsAssignableFrom(Of PENamedTypeSymbol)(userComp.GetTypeByMetadataName("C"))
+
+            Dim i = cMetadataType.GetMethod("I")
+            Assert.False(i.IsIterator)
+        End Sub
+
         <Fact()>
         Public Sub IteratorNoYields()
             Dim compilation = CreateCompilationWithMscorlib40AndVBRuntime(
@@ -1021,6 +1068,30 @@ End Class
             CompileAndVerify(compilation, expectedOutput:="123")
         End Sub
 
+        <Fact>
+        Public Sub IteratorProperty_Metadata()
+            Dim sourceComp = CreateCompilation(
+<compilation>
+    <file name="a.vb"><![CDATA[
+Imports System.Collections.Generic
+
+Class C
+    Iterator ReadOnly Property P As IEnumerable(Of Integer)
+        Get
+            Yield 1
+        End Get
+    End Property
+End Class
+]]></file>
+</compilation>).VerifyDiagnostics()
+
+            Dim userComp = CreateCompilation("", references:={sourceComp.EmitToImageReference()}).VerifyDiagnostics()
+            Dim cMetadataType = Assert.IsAssignableFrom(Of PENamedTypeSymbol)(userComp.GetTypeByMetadataName("C"))
+
+            Dim [property] = cMetadataType.GetProperty("P")
+            Assert.False([property].GetMethod.IsIterator)
+        End Sub
+
         <Fact()>
         Public Sub CompilerLoweringPreserveAttribute_01()
             Dim source1 = "

src/Features/Core/Portable/MetadataAsSource/AbstractMetadataAsSourceService.WrappedMethodSymbol.cs

@@ -127,6 +127,8 @@ public IMethodSymbol ReduceExtensionMethod(ITypeSymbol receiverType)
 
         public bool IsConditional => _symbol.IsConditional;
 
+        public bool IsIterator => _symbol.IsIterator;
+
         public SignatureCallingConvention CallingConvention => _symbol.CallingConvention;
 
         public ImmutableArray<INamedTypeSymbol> UnmanagedCallingConventionTypes => _symbol.UnmanagedCallingConventionTypes;

src/Tools/SemanticSearch/ReferenceAssemblies/Apis/Microsoft.CodeAnalysis.txt

@@ -1241,6 +1241,7 @@ Microsoft.CodeAnalysis.IMethodSymbol.get_IsConditional
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsExtensionMethod
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsGenericMethod
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsInitOnly
+Microsoft.CodeAnalysis.IMethodSymbol.get_IsIterator
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsPartialDefinition
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsReadOnly
 Microsoft.CodeAnalysis.IMethodSymbol.get_IsVararg

src/Workspaces/SharedUtilitiesAndExtensions/Workspace/Core/CodeGeneration/Symbols/CodeGenerationAbstractMethodSymbol.cs

@@ -104,6 +104,8 @@ public virtual ImmutableArray<CustomModifier> ReturnTypeCustomModifiers
 
     public bool IsConditional => false;
 
+    public bool IsIterator => false;
+
     public SignatureCallingConvention CallingConvention => SignatureCallingConvention.Default;
 
     public ImmutableArray<INamedTypeSymbol> UnmanagedCallingConventionTypes => [];