Make scripts be root chunks that can have local statements

Core/EVIL.Grammar/AST/Miscellaneous/ProgramNode.cs

@@ -1,13 +1,18 @@
 using System.Collections.Generic;
+using System.Linq;
 using EVIL.Grammar.AST.Base;
+using EVIL.Grammar.AST.Statements.TopLevel;
 
 namespace EVIL.Grammar.AST.Miscellaneous
 {
     public sealed class ProgramNode : AstNode
     {
-        public List<TopLevelStatement> Statements { get; } 
+        public IEnumerable<Statement> FnStatements => Statements.Where(x => x is FnStatement);
+        public IEnumerable<Statement> AnythingButFnStatements => Statements.Where(x => x is not FnStatement);
+
+        public List<Statement> Statements { get; } 
 
-        public ProgramNode(List<TopLevelStatement> statements)
+        public ProgramNode(List<Statement> statements)
         {
             Statements = statements;
             Reparent(Statements);

Core/EVIL.Grammar/AST/Statements/TopLevel/AttributeListNode.cs → Core/EVIL.Grammar/AST/Statements/AttributeListNode.cs

@@ -4,7 +4,7 @@
 
 namespace EVIL.Grammar.AST.Statements.TopLevel
 {
-    public class AttributeListNode : TopLevelStatement
+    public class AttributeListNode : Statement
     {
         public List<AttributeNode> Attributes { get; }
 

Core/EVIL.Grammar/AST/Statements/TopLevel/FnStatement.cs → Core/EVIL.Grammar/AST/Statements/FnStatement.cs

@@ -4,7 +4,7 @@
 
 namespace EVIL.Grammar.AST.Statements.TopLevel
 {
-    public sealed class FnStatement : TopLevelStatement
+    public sealed class FnStatement : Statement
     {
         public IdentifierNode Identifier { get; }
         public ParameterList ParameterList { get; }

Core/EVIL.Grammar/Parsing/Base/Parser.Statement.cs

@@ -15,6 +15,10 @@ private Statement Statement()
 
             switch (token.Type)
             {
+                case TokenType.AttributeList:
+                case TokenType.Fn:
+                    return FnStatement();
+
                 case TokenType.If:
                     return IfCondition();
 

Core/EVIL.Grammar/Parsing/Expressions/Parser.Indexing.cs → Core/EVIL.Grammar/Parsing/Expressions/Parser.IndexerExpression.cs

@@ -7,7 +7,7 @@ namespace EVIL.Grammar.Parsing
 {
     public partial class Parser
     {
-        private IndexerExpression Indexing(Expression indexable)
+        private IndexerExpression IndexerExpression(Expression indexable)
         {
             int line, col;
             Expression indexer;

Core/EVIL.Grammar/Parsing/Expressions/Parser.FunctionCall.cs → Core/EVIL.Grammar/Parsing/Expressions/Parser.InvocationExpression.cs

@@ -6,7 +6,7 @@ namespace EVIL.Grammar.Parsing
 {
     public partial class Parser
     {
-        private InvocationExpression FunctionCall(Expression callee)
+        private InvocationExpression InvocationExpression(Expression callee)
         {
             var (line, col) = (_lexer.State.Line, _lexer.State.Column);
 

Core/EVIL.Grammar/Parsing/Expressions/Parser.PostfixExpression.cs

@@ -45,11 +45,11 @@ private Expression PostfixExpression()
 
                 if (token.Type == TokenType.LParenthesis)
                 {
-                    node = FunctionCall(node);
+                    node = InvocationExpression(node);
                 }
                 else if (token.Type == TokenType.LBracket || token.Type == TokenType.Dot)
                 {
-                    node = Indexing(node);
+                    node = IndexerExpression(node);
                 }
                 else if (token.Type == TokenType.DoubleColon)
                 {

Core/EVIL.Grammar/Parsing/Miscellaneous/Parser.Program.cs

@@ -9,7 +9,7 @@ public partial class Parser
     {
         private ProgramNode Program()
         {
-            var statementList = new List<TopLevelStatement>();
+            var statementList = new List<Statement>();
 
             if (CurrentToken == Token.Empty)
             {
@@ -22,7 +22,7 @@ private ProgramNode Program()
             while (CurrentToken.Type != TokenType.EOF)
             {
                 statementList.Add(
-                    TopLevelStatement()
+                    Statement()
                 );
             }
 

Core/EVIL.Grammar/Parsing/Statements/Parser.EachLoop.cs

@@ -14,7 +14,7 @@ private EachStatement EachLoop()
             if (CurrentToken == Token.Val)
             {
                 throw new ParserException(
-                    "Each-loop variables must be `rw'.",
+                    "Each-loop variables must be 'rw'.",
                     (_lexer.State.Line, _lexer.State.Column)
                 );
             }

Core/EVIL.Grammar/Parsing/Statements/TopLevel/Parser.FnStatement.cs → Core/EVIL.Grammar/Parsing/Statements/Parser.FnStatement.cs

@@ -18,6 +18,14 @@ private FnStatement FnStatement()
             }
 
             var (line, col) = Match(Token.Fn);
+            if (_functionDescent > 0)
+            {
+                throw new ParserException(
+                    "Named function definitions may only appear outside of other functions.",
+                    (line, col)
+                );
+            }
+
             var functionIdentifier = Identifier();
             var parameterList = ParameterList();
 

Core/EVIL.Grammar/Traversal/AstVisitor.cs

@@ -20,7 +20,6 @@ protected AstVisitor()
 #nullable disable
             Handlers = new()
             {
-                { typeof(IncludeStatement), (n) => Visit((IncludeStatement)n) },
                 { typeof(ArgumentList), (n) => Visit((ArgumentList)n) },
                 { typeof(ParameterList), (n) => Visit((ParameterList)n) },
                 { typeof(BlockStatement), (n) => Visit((BlockStatement)n) },
@@ -85,7 +84,6 @@ public virtual void Visit(AstNode node)
         public abstract void Visit(ProgramNode programNode);
         public abstract void Visit(ParameterList parameterList);
         public abstract void Visit(ArgumentList argumentList);
-        public abstract void Visit(IncludeStatement includeStatement);
         public abstract void Visit(BlockStatement blockStatement);
         public abstract void Visit(ConditionalExpression conditionalExpression);
         public abstract void Visit(CoalescingExpression coalescingExpression);

Core/EVIL.Lexical/Lexer.cs

@@ -43,16 +43,6 @@ public void NextToken()
             State.PreviousToken = State.CurrentToken;
             var (line, col) = (State.Line, State.Column);
 
-            if (col == 1)
-            {
-                if (State.Character == '#' && PeekString(7) == "include")
-                {
-                    Advance(8);
-                    State.CurrentToken = Token.Include with { Line = line, Column = col };
-                    return;
-                }
-            }
-
             switch (State.Character)
             {
                 case '.' when Peek() == '.' && Peek(2) == '.':

Core/EVIL.Lexical/Token.cs

@@ -184,7 +184,6 @@ public override int GetHashCode()
         public static readonly Token HexInteger = new(TokenType.HexInteger, TokenClass.Literal, string.Empty);
         public static readonly Token String = new(TokenType.String, TokenClass.Literal, string.Empty);
 
-        public static readonly Token Include = new(TokenType.Include, TokenClass.Meta, "#include");
         public static readonly Token EOF = new(TokenType.EOF, TokenClass.Meta, "<EOF>");
         public static readonly Token Empty = new(TokenType.Empty, TokenClass.Meta, string.Empty);
     }

Core/EVIL.Lexical/TokenType.cs

@@ -146,8 +146,7 @@ public enum TokenType
         GetOverride,
         SetOverride,
         ExistsOverride,
-
-        Include,
+
         EOF
     }
 }

Core/Tests/EVIL.CoreTests/LexerTests.cs

@@ -213,15 +213,5 @@ public void TypeCodes()
             Expect(NativeFunctionTypeCode, NativeObjectTypeCode);
             Expect(EOF);
         }
-
-        [Test]
-        public void Meta()
-        {
-            _lexer.LoadSource("#include \"test.vil\"");
-
-            Expect(Include);
-            ExpectExact((TokenType.String, "test.vil"));
-            Expect(EOF);
-        }
     }
 }