C# 7.x §15.15.1 task type must not have multiple type arguments

[KalleOlaviNiemitalo]

Describe the bug

In the C# 7.x draft, §15.15.1 (Async functions / General) restricts the genericity of a task type:

For an async method that returns a value, a task type shall be generic. For an async method that does not return a value, a task type shall not be generic.

This allows a constructed task type with more than one type argument, but Roslyn does not support that.

Example

The standard should not allow:

using System;
using System.Runtime.CompilerServices;

class C {
    // «TaskType»<T> is CustomTask<int, int>.
    // «TaskBuilderType»<T> is not clear, but not outright disallowed either.
    async CustomTask<int, int> M() => 1; // error CS1983
}

[AsyncMethodBuilder(typeof(CustomTaskBuilder<>))]
public struct CustomTask<T1, T2> {}

public struct CustomTaskBuilder<TResult> {
    public static CustomTaskBuilder<TResult> Create() => default;
    public void Start<TStateMachine>(
        ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine {}
    public void SetStateMachine(
        IAsyncStateMachine stateMachine) {}
    public void SetException(
        Exception exception) {}
    public void SetResult(TResult result) {}
    public void AwaitOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}
    public void AwaitUnsafeOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}
    public CustomTask<TResult, TResult> Task => default;
}

Expected behavior

Declare that the task type shall not have more than one type argument.

(Use "type argument" rather than "type parameter", because task types are constructed types.)

Additional context

Unlike a task builder type, a task type can be nested in a generic type. Example:

using System;
using System.Runtime.CompilerServices;

class C {
    // «TaskType»<T> is Outer<char>.CustomTask<int>.
    // «TaskBuilderType»<T> is CustomTaskBuilder<int>; the type argument in Outer<char> does not affect this.
    async Outer<char>.CustomTask<int> M() => 1;
}

public class Outer<T1> {
    [AsyncMethodBuilder(typeof(CustomTaskBuilder<>))]
    public struct CustomTask<T2> {}
}

public struct CustomTaskBuilder<TResult> {
    public static CustomTaskBuilder<TResult> Create() => default;
    public void Start<TStateMachine>(
        ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine {}
    public void SetStateMachine(
        IAsyncStateMachine stateMachine) {}
    public void SetException(
        Exception exception) {}
    public void SetResult(TResult result) {}
    public void AwaitOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}
    public void AwaitUnsafeOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}
    public Outer<char>.CustomTask<TResult> Task => default;
}

[KalleOlaviNiemitalo]

Fixing this is complicated by the following paragraph in §15.2.1:

A class declaration that supplies a type_parameter_list is a generic class declaration. Additionally, any class nested inside a generic class declaration or a generic struct declaration is itself a generic class declaration, since type arguments for the containing type shall be supplied to create a constructed type (§8.4).

interacting with §15.15.1

For an async method that does not return a value, a task type shall not be generic.

when the task type is nested in a generic type. Perhaps then, §15.15.1 should talk about the presence or absence of a type_parameter_list, rather than the type being generic or not.

[KalleOlaviNiemitalo]

Got a funny idea for how to define a task builder for a task type nested in a generic type, without hardcoding the type arguments of the containing type. Alas, Roslyn rejects it, and the current C# 7.x wording doesn't allow it either.

using System;
using System.Runtime.CompilerServices;

class C {
    // «TaskType»<T> is Outer<char>.CustomTask<int>.
    // «TaskBuilderType»<T> is CustomTaskBuilder<int>; the type argument in Outer<char> does not affect this.
    async Outer<char>.CustomTask<int> M() => 1; // error CS8204
}

public class Outer<T1> {
    [AsyncMethodBuilder(typeof(CustomTaskBuilder<>))]
    public struct CustomTask<T2>
    {
        public static implicit operator CustomTask<T2>(
            CustomTaskBuilder<T2>.ConvertibleTask convertibleTask)
        => default;
    }
}

public struct CustomTaskBuilder<TResult> {
    public static CustomTaskBuilder<TResult> Create() => default;
    public void Start<TStateMachine>(
        ref TStateMachine stateMachine)
        where TStateMachine : IAsyncStateMachine {}
    public void SetStateMachine(
        IAsyncStateMachine stateMachine) {}
    public void SetException(
        Exception exception) {}
    public void SetResult(TResult result) {}
    public void AwaitOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}
    public void AwaitUnsafeOnCompleted<TAwaiter,TStateMachine>(
        ref TAwaiter awaiter,
        ref TStateMachine stateMachine)
        where TAwaiter : INotifyCompletion
        where TStateMachine : IAsyncStateMachine {}

    // This is not exactly «TaskType»<T>, but has an implicit conversion to that.
    public ConvertibleTask Task => default;
    
    public struct ConvertibleTask {}
}

[jskeet]

Thinking about this in the context of #875, I think I'll make a change to prohibit generic containing types entirely. It makes everything much simpler... I think we can leave any laxness on Roslyn's side as an extension for now.

[jskeet]

Closed by #875.