Sticky scroll - keep containers headers visible when scrolling

[gulshan]

This is a feature request. Starting with an example. Suppose we have following c# file-

using System;

namespace ExampleNamespace
{
    class ExampleClass
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello World!");
        }

        static void ExampleMethod1()
        {
            Console.WriteLine("ExampleMethod1");
        }

        static void ExampleMethod2()
        {
            var methodName = "ExampleMethod2";

            foreach(var c in methodName)
            {
                if(char.IsUpper(c))
                {
                    Console.WriteLine("Upper case");
                }
                else
                {
                    Console.WriteLine("Lower case");
                }
            }
        }
    }
}

If we are browsing the file at the end, it looks like this now-

And with this feature, I wish it to look something like this-

It means the parent syntax nodes of the area being browsed is automatically freezed, so that the user can easily guess the context of the current code, regardless of how far the parent nodes are. Some points being-

• I think this should be a toggle keystroke to on/off feature, may or may not backed by a setting.
• The parent syntax nodes should smoothly stack up or goes out of stack while scrolling.
• This should be tied with the current viewport and not current cursor position in my opinion.
• It would be nice to have previous sibling nodes included in the stack for if-else chains and switch cases.
• By default, this can be solely based on indentation instead of actual syntax tree of the language, just like how folding currently works in vscode.
• There should be a minimum height of the viewport with actual code (without parent nodes). Or maximum height of parent node (header) lines. When that value will be reached (like for heavily nested code), furthest or top most parent nodes can be hidden in that order. The closes parent nodes will remain visible.

Edit:
Found a nice illustration for this feature from this tweet-

[aeschli]

Interesting idea! @egamma @alexandrudima FYI.

[PEZO19]

I really like the idea, I have something very similar. I believe code folding could be use many ways to make code easier to absorb.
I wonder is there any other editor which has similar code folding strategy?

[gulshan]

I don't know any other editor with this kind of code folding feature.

[pr-yemibedu]

Hello,
This Peeking fold is nice. Some settings could be:

• folding.enablePeeking = true
• folding.peekingDepth = {0 = unlimited, 1 = one level in, 2 = two levels in, ... , n}

So what I would like to see is more (+) in the left border to indicate a way to collapse or expand. Also this can be a lot easier to get in vscode if there are not a lot of limits. The OP made six points ATTOW and so:

1. it could be a keyboard ready toggle, but being backed by a setting gives a user the choice to anchor the toggle direction.
2. ? the code tells the tale told by the programmer, no ?
3. agreed
4. special cases break expectations of ident based folding.
5. agreed
6. sounds like my second setting, but it maybe not poping into a fold based on anymore than matching the current level count

This is one of those so simple looking additions to the editor that it would be a crime to leave out. Thank you. Good day.

[gulshan]

I thought user may not want to keep this settings on always. It will help more in code exploring situations. But may be someone will want to keep it on permanently. Then I have no objection to a permanent settings.

Regarding branching nodes like if, else-if, else, cases for switch or others, it's true that freezing previous sibling node headers violates indent based folding expectations and the feature will then require language awareness of some sort. So the first or baseline implementation can leave it. But I think it's still a nice to have enhancement and language servers should be able to contribute to this part.

[gulshan]

One thing! When this feature is turned on, the usual code-folding has to be turned off. So enabling this can be part of editor.folding settings.

[gulshan]

This tweet has a nice illustration for this feature-
https://twitter.com/jckarter/status/1140131108564062213

[wayou]

Since the frozen part will take vertical space, it's better to limit the rows and collapse the middle rows with an explicit expand button.

Something like this:

class Foo{
...Expand 3+ hidden parent nodes...
	constructor(public name:string){
---------------------------------------
	// other codes...
	}
}