[Proposal]: [call local static functions in base constructor]

[mstaros]

call local static functions in base constructor

• Proposed
• Prototype: Not Started
• Implementation: Not Started
• Specification: Not Started

Summary

Today to calculate parameters to be sent from derived class constructor to base constructor one has to define additional static method in derived class. It would be nice to use local static function instead.

Motivation

Not to litter class members scope with functions that should be encapsulated as local ones.

Example

class A
 {
     public A(int x)
    {
        ...
    }
}
class B:A {
   public B(int z):base(Local(z))
   {
            static int Local(int h)
            {
                 ...
            }
   }
}

Drawbacks

Alternatives

Unresolved questions

Design meetings

https://github.com/dotnet/csharplang/blob/master/meetings/2020/LDM-2020-10-26.md#static-local-functions-in-base-calls
https://github.com/dotnet/csharplang/blob/main/meetings/2022/LDM-2022-09-28.md#ungrouped

[YairHalberstadt]

Are there any other things ordinary static methods can do, but local static methods can't? It's probably worthwhile to collect a list of them all and try to do as many of them as possible in one go.

[333fred]

It surprises me that this isn't something we already support. I'm interested in championing this, specifically for static local functions only.

[YairHalberstadt]

@333fred the reason this isn't supported is because of name lookup. I think it will be a breaking change to make local functions in scope in the base constructor.

[YairHalberstadt]

e.g.

using System;

Console.WriteLine(new Derived().A);

class Base
{
    public int A;
    protected Base(int a) => A = a;
}

class Derived : Base
{
    public Derived() : base(GetInt())
    {
        static int GetInt() => 42;
    }
    
    static int GetInt() => 41;
}

😢

[Youssef1313]

@YairHalberstadt I don't think it's a big deal. We can give the static methods at class level (i.e, the one returns 41 in your example) a priority when it's being called in base. (With a warning in a warning wave when a local function has the same name as a method in the class level)

[YairHalberstadt]

@Youssef1313

I think that would be concerning, because imaging I had this code:

using System;
using static SomeClass;

class Base
{
    public int A;
    protected Base(int a) => A = a;
}

class Derived : Base
{
    public Derived() : base(GetInt())
    {
        static int GetInt() => 42;
    }
}

This would work fine. Now somebody adds a static int GetInt() method to SomeClass and my code changes to call that method silently, instead of the local function.

[HaloFour]

IMO I'd rather evaluate whether it's acceptable to take the source-breaking change and have only the local function be in scope, to keep it consistent with local functions in normal methods. What is the likelihood that someone is calling a static function in their base constructor call that happens to have the same name as a local function defined within that constructor?

[YairHalberstadt]

If the breaking change were considered acceptable, would it be ideal to try and stuff this into C# 9 to limit the chance of anyone being broken by this?

[YairHalberstadt]

Also would local functions and static local functions have different scope to limit the breakages? local functions were introduced 3 years ago, and static local functions only last year. Only static local functions are useful in base classes.

Furthermore, would we want to do this for this constructor calls as well?

[Youssef1313]

@Youssef1313

I think that would be concerning, because imaging I had this code:

using System;
using static SomeClass;

class Base
{
    public int A;
    protected Base(int a) => A = a;
}

class Derived : Base
{
    public Derived() : base(GetInt())
    {
        static int GetInt() => 42;
    }
}

This would work fine. Now somebody adds a static int GetInt() method to SomeClass and my code changes to call that method silently, instead of the local function.

In this case, I think a normal warning ("The call to '{0}' in base() is ambiguous between a static local function and a static method") could be added (keep the warning limited to calls in base)

[Youssef1313]

Furthermore, would we want to do this for this constructor calls as well?

IMO Yes. There is no reason for this to be allowed in base(...) but not this(...).

[YairHalberstadt]

In this case, I think a normal warning ("The call to '{0}' in base() is ambiguous between a static local function and a static method") could be added (keep the warning limited to calls in base)

That would break existing code.