Option Explicit

    Public _
        Sub _
    foo()

    Debug.Print ""foo""

    End _
        Sub

        public static int EndColumn(this IToken token)
        {
            if (token.Text.Contains(Environment.NewLine))
            {
                var splitStrings = token.Text.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries);
                var tokenOnLastLine = splitStrings[splitStrings.Length - 1];

                return tokenOnLastLine.Length;
            }
            else
            {
                return token.Column + token.Text.Length;
            }

        private class NodeVisitor<ParserRuleContext> : VBAParserBaseVisitor<ParserRuleContext>
        {
            private List<SubStmtContext> _contexts = new List<SubStmtContext>();

            public List<SubStmtContext> Contexts { get { return _contexts; } }

            public override ParserRuleContext VisitSubStmt([NotNull] SubStmtContext context)
            {
                _contexts.Add(context);
                return base.VisitSubStmt(context);
            }
        }

[TestMethod]
        [TestCategory("Grammar")]
        public void Token_Not_In_Selection_ZeroBased()
        {
            const string inputCode = @"
Option Explicit

Public _
    Sub _
foo()

Debug.Print ""foo""

    End _
  Sub : 'Lame comment!
";

            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
            var state = MockParser.CreateAndParse(vbe.Object);
            var tree = state.GetParseTree(new QualifiedModuleName(component));
            var visitor = new NodeVisitor<SubStmtContext>();

        [TestMethod]
        [TestCategory("Grammar")]
        public void Token_In_Selection_OneBased()
        {
            const string inputCode = @"
Option Explicit

Public _
    Sub _
foo()

Debug.Print ""foo""

    End _
  Sub : 'Lame comment!
";

            var vbe = MockVbeBuilder.BuildFromSingleStandardModule(inputCode, out var component);
            var state = MockParser.CreateAndParse(vbe.Object);
            var tree = state.GetParseTree(new QualifiedModuleName(component));
            var visitor = new NodeVisitor<SubStmtContext>();

public static bool Contains(this ParserRuleContext context, Selection selection)
{
    return
       ((((selection.StartLine - 1) == context.Start.Line) && (selection.StartColumn - 1) <= context.Start.Column) || ((selection.StartLine - 1) < context.Start.Line))
    && ((((selection.EndLine - 1) == context.Stop.Line) && (selection.EndColumn - 1) >= (context.Stop.Column + context.Stop.Text.Length)) || (selection.EndLine - 1) > context.Stop.Line);
}

Sub F[oo]
End Sub

Dim val As Boolean
val = True
If val Then

    public class CollectorVBAParserBaseVisitor<Result> : VBAParserBaseVisitor<IEnumerable<Result>>
    {
        protected override IEnumerable<Result> DefaultResult => new List<Result>();

        protected override IEnumerable<Result> AggregateResult(IEnumerable<Result> firstResult, IEnumerable<Result> secondResult)
        {
            return firstResult.Concat(secondResult);
        }
    }

    public class ModuleBodyElementCollectorVisitor : CollectorVBAParserBaseVisitor<VBAParser.ModuleBodyElementContext>

Foo(Type1 arg1, Type2 arg2) : this(arg1)

public MyClass(string foo) : this(foo, 42) { }

public MyClass(string foo, int bar)
{
     // do stuff
}

public class Program
{
	public static void Main()
	{
		Dog foo = new Dog("bar");
		Console.WriteLine(foo);
	}

	public class Dog
	{
		public string Name { get; set; }
		public int Age { get; set; }
		public string Motto { get; set; }

		public Dog(string Name) : this(Name, 1, "Happy") {}

		public Dog(string name, int age) : this( name, age, "Happy") {}

		public Dog(string Name, int Age, string Motto)
		{
			this.Name = Name;
			this.Age = Age;
			this.Motto = Motto;
		}
		public override string ToString()

class Program
{
    static void Main(string[] args)
    {
        new Foo(9);
    }
}

public class Foo
{
    public Foo()
    {
        Console.WriteLine("Hi 1");
    }
    public Foo(int i) : this()
    {
        Console.WriteLine("Hi 2");
    }
}

public class Foo
{
    private readonly int s;

    public Foo()
    {
        s = -1;
        Console.WriteLine(s);
    }
    public Foo(int i) : this()
    {
        s = i;
        Console.WriteLine(s);
    }
}

public Foo() : this(42) { /* nevermind @Hosch250, this runs after the base ctor too  */ }
public Foo(int bar) : base(bar) { }

    class Program
    {
        static void Main(string[] args)
        {
            new Foo1(9);
        }
    }

    public abstract class Foo
    {
        protected Foo(int i)
        {
            Console.WriteLine("base");
            Fizz();
        }

        public abstract void Fizz();
    }

    public class Foo1 : Foo
    {
        private int _i = -1;

        public Foo1() : base(0)
        {
            _i = 10;
            Console.WriteLine("empty");
        }

        public Foo1(int i) : this()

public class Program
{
	public static void Main()
	{
		Foo foo = new Foo(5);
	}

	public class Foo : Bar
	{
		private readonly int s;

		public Foo()
		{
			s = -1;
			Console.WriteLine(s);
		}
		public Foo(int i) : this()
		{
			DukheadedMistake();
			s = i;
			Console.WriteLine(s);
		}

		public override void DukheadedMistake()
		{
			Console.WriteLine("Really really messed up.");
		}
	}

	public class Bar
	{
		public Bar()
		{
			DukheadedMistake();
		}
		public virtual void DukheadedMistake()

public class Program
{
	public static void Main()
	{
		Foo noParams = new Foo();
		noParams.writeOut();

		Foo barParam = new Foo(99);
		barParam.writeOut();

		Foo buzzParam = new Foo("beeble");
		buzzParam.writeOut();

		Foo barbuzzParam = new Foo(55, "bobble");
		barbuzzParam.writeOut();
	}

	public class Foo
	{
		public int bar = 5;
		public string buzz = "BuzzBar";

		public Foo(int bar)
		{
			this.bar = bar; //writes over 5
		}

		public Foo(string buzz)
		{
			this.buzz = buzz; //writes over "BuzzBar"

    public class Foo1
    {
        public Foo1()
        {
            i = new Bar();
            Console.WriteLine(I == null);
        }

        private static Bar i;
        private Bar I { get; } = i;
    }

    public class Bar{}

:39945597 	public class Foo1
    	{
    		public Foo1()
    		{

    			i = new Bar();
    			this.I = i;
    			Console.WriteLine(I == null);
    		}

    		private static Bar i;
    		private Bar I { get; set; }
    	}

    	public class Bar{}