Static locals

[TahirAhmadov]

Based on the extensive discussion in #832

Let's introduce static locals to C#. Proposed syntax:

class MyClass
{
  int _x = 5;
  int c = 123;

  public static void Foo() // static method
  {
    static int a = 5; // triggers the creation of a private static nested class of MyClass,
    // named something like "<generated>Foo_Statics" (using similar logic to anonymous types, etc.)
    // same as adding the following to Foo_Statics: static int a = 5;
    static var b = 8; // allow "var" syntax to be consistent with other locals; "static int b = 8;" in "Foo_Statics"
    static string e; // this is included in nullability analysis (warning: e is potentially null)
    static string? f; // no warning here - f == null by default
    static string g = "abc"; // same here - g is initialized, so not null
    static readonly Regex rgx = new Regex("..."); // this is very useful - defer initialization to this method being called. 
    // Same as adding this to aforementioned "Foo_Statics": static readonly rgx = new Regex("...");
    // Regular framework handling of thread-safe static init works fine on "Foo_Statics"
    ++a; // same as: ++Foo_Statics.a;
    Console.WriteLine(a);
    int bLocal = Interlocked.Increment(ref b); // gotta be thread safe sometimes
    Console.WriteLine(bLocal);
    var m = rgx.Match("..."); // same as: var m = Foo_Statics.rgx.Match("...");
    Baz(static new[] { "a", "b", "c" }); 
    // adds the following to Foo_Statics: static readonly string[] <InlineLocal>ASDASD = new[] { "a", "b", "c" };
    // the call becomes: Baz(Foo_Statics.<InlineLocal>ASDASD);
  }
  public void Foo<T1, T2>() where T1 : IDisposable
  {
    static int a = 5; // the statics class is generic, copying it's generic signature from Foo<T1, T2>
    // same as: private static class <mangled>Foo_Statics<T1, T2> where T1 : IDisposable { static int a = 5; } 
    static T1? b; // we can use method's generic arguments for these static local fields, which is a great plus

    static nongeneric int c = 6; 
    // creates MyClass_Foo_T1_T2_NonGenericStatics class (below)
  }
  public void Bar() // instance method
  {
    static int a = 5; // works identically to Foo: class Bar_Statics { static int a = 1; }
    static readonly Regex rgx = new Regex("..."); // this is very useful in instance methods, too
    ++a; // same as: ++Bar_Statics.a;
    Console.WriteLine(a);
    var m = rgx.Match("..."); // same as: var m = Bar_Statics.rgx.Match("...");

    // I think the below isn't super helpful, but for those who want the benefits of scoping, here goes:
    instance int c = 5; // adds a private field to MyClass named something like "<generated>Bar_c"; 
    // field is set to 5 when class is created, as usual. 
    // Note the introduction of a new keyword (has to be decided if it can be contextual)
    // "c" is very similar to "_x"; it's only different in scoping
    // it is DIFFERENT than MyClass.c field:
    ++c; // increment the instance local field
    ++this.c; // increment the class-scope field declared on top
    instance int d; // same as above, but no initialization, defaults to 0
    instance string e; // this is included in nullability analysis (warning: e is potentially null)
    instance string? f; // no warning here - f == null by default
    instance string g = "abc"; // same here - g is initialized, so not null
    //instance readonly int h = 1; // I think this doesn't really work; constructor cannot see this field, 
    // so it can only be assigned a constant; at which point it's no better than a static readonly field (see above)
  }

  public static int StaticProp
  {
    static int staticProp;
    get => staticProp - 5; set => staticProp = value + 5;
  }
  public int Prop
  {
    static int staticField;
    instance int prop;
    get => prop - 5; set { prop = value + 5; ++staticField; }
  }

  public static event EventHandler StaticEvent
  {
    static int staticField; // this can be useful, I suppose
    static EventHandler v; // this is pretty useless - unless we allow defining the getter below
    add { v += value; ++staticField; } remove { v -= value; --staticField; } private get { return v; }
  }
  public event EventHandler Event
  {
    static int staticField; // this can be useful, I suppose
    instance EventHandler v; // this is pretty useless - unless we allow defining the getter below
    add { v += value; ++staticField; } remove { v -= value; --staticField; } private get { return v; }
  }
}
// this class is created due to "nongeneric" keyword inside a generic method
static class MyClass_Foo_T1_T2_NonGenericStatics
{
  internal static nongeneric int c = 6; 
}

MyClass.Foo(); // outputs "6" and "9" to console
MyClass.Foo(); // outputs "7" and "10" to console
new MyClass().Bar(); // outputs "6" to console
new MyClass().Bar(); // outputs "7" to console

Please provide feedback and I'll update the post as needed.

[HaloFour]

There's no need to open a separate discussion on this topic.

[CyrusNajmabadi]

and the OP in it doesn't have a fully specced out proposal

That's what a discussion is intended to get to.

[TahirAhmadov]

That's the thing - I think there is a concrete proposal that addresses all of the ideas in that discussion, which is this OP. Including generics, etc.

[TahirAhmadov]

@CyrusNajmabadi why did you close it? This is not a duplicate - that previous thread is a discussion, whereas this one is a language proposal.

[HaloFour]

You can include your proposed syntax and policies in that discussion.

[CyrusNajmabadi]

Both are discussions. And both are any the exact same topic. That's literally what the original discussion is for. Within that discussion you can bring up your concrete proposal and it can be discussed there. That is literally the purpose of that discussion.

If that proposal is liked by the language team, it can be converted into a real issue tracking it.

Thanks!