analyzer

Author: hikariatama

compiler/Program.cs

@@ -1,6 +1,8 @@
 using System.Text;
 using System.Text.Json;
 using System.Text.Json.Serialization;
+using MiniLang.Semantic;
+using MiniLang.Syntax;
 
 public class Program
 {
@@ -81,21 +83,62 @@ public static void Main(string[] args)
 
         try
         {
-            var tokens = new Lexer(sourceCode).ScanTokens();
-            var analyzer = new Analyzer();
-            var ast = analyzer.analyze(tokens);
             var options = new JsonSerializerOptions
             {
                 Converters = { new JsonStringEnumConverter() },
-                MaxDepth = 2048
+                MaxDepth = 2048,
+                WriteIndented = false
             };
-            var json = JsonSerializer.Serialize(ast, options);
-            writer.WriteLine(json);
-        }
-        catch (SyntaxError e)
-        {
-            Console.Error.WriteLine(e.Message);
-            Environment.ExitCode = 1;
+
+            IReadOnlyList<Token> tokens;
+            try
+            {
+                tokens = new Lexer(sourceCode).ScanTokens();
+            }
+            catch (SyntaxError le)
+            {
+                var lexErr = new Diagnostic(Stage.Lex, le.Line, le.Message, Severity.Error);
+                var output = new PipelineOutput(Array.Empty<Token>(), null, new SemanticReport(Array.Empty<Diagnostic>(), Array.Empty<Diagnostic>()), null, lexErr, null, null);
+                writer.WriteLine(JsonSerializer.Serialize(output, options));
+                return;
+            }
+
+            ProgramAst? ast = null;
+            try
+            {
+                var analyzer = new Analyzer();
+                ast = analyzer.analyze(tokens);
+            }
+            catch (SyntaxError pe)
+            {
+                var parseErr = new Diagnostic(Stage.Parse, pe.Line, pe.Message, Severity.Error);
+                var output = new PipelineOutput(tokens, null, new SemanticReport(Array.Empty<Diagnostic>(), Array.Empty<Diagnostic>()), null, parseErr, null, null);
+                writer.WriteLine(JsonSerializer.Serialize(output, options));
+                return;
+            }
+
+            var sema = new SemanticAnalyzer();
+            var report = sema.Analyze(ast, sourceCode);
+
+            ProgramAst? optimized = null;
+            List<Optimizer.OptimizationStep>? steps = null;
+            string? optimizedSource = null;
+            try
+            {
+                var res = Optimizer.OptimizeWithReport(ast);
+                optimized = res.Program;
+                steps = res.Steps;
+                optimizedSource = optimized != null ? CodePrinter.PrintProgram(optimized) : null;
+            }
+            catch
+            {
+                optimized = null;
+                steps = null;
+                optimizedSource = null;
+            }
+
+            var result = new PipelineOutput(tokens, ast, report, optimized, null, steps, optimizedSource);
+            writer.WriteLine(JsonSerializer.Serialize(result, options));
         }
         catch (Exception e)
         {

compiler/analyzer/Analyzer.cs

@@ -219,6 +219,7 @@ private Statement ParseStatement()
             if (Current.Type == TokenType.While) return ParseWhile();
             if (Current.Type == TokenType.If) return ParseIf();
             if (Current.Type == TokenType.Return) return ParseReturn();
+            if (Current.Type == TokenType.Break) return ParseBreak();
             var lhs = ParseExpression();
             if (Match(TokenType.ColonEqual))
             {
@@ -264,6 +265,12 @@ private ReturnStmt ParseReturn()
             return new ReturnStmt(expr, r.Line);
         }
 
+        private BreakStmt ParseBreak()
+        {
+            var b = Consume(TokenType.Break, "'break'");
+            return new BreakStmt(b.Line);
+        }
+
         private Expression ParseExpression() => ParsePostfix();
 
         private Expression ParsePostfix()

compiler/analyzer/Ast.cs

@@ -15,6 +15,7 @@ public sealed record ProgramAst(IReadOnlyList<TopLevelNode> Items) : AstNode(0);
     [JsonDerivedType(typeof(WhileStmt), "while")]
     [JsonDerivedType(typeof(IfStmt), "if")]
     [JsonDerivedType(typeof(ReturnStmt), "return")]
+    [JsonDerivedType(typeof(BreakStmt), "break")]
     public abstract record TopLevelNode(int Line) : AstNode(Line);
 
     [JsonPolymorphic(TypeDiscriminatorPropertyName = "stmt")]
@@ -24,6 +25,7 @@ public abstract record TopLevelNode(int Line) : AstNode(Line);
     [JsonDerivedType(typeof(WhileStmt), "while")]
     [JsonDerivedType(typeof(IfStmt), "if")]
     [JsonDerivedType(typeof(ReturnStmt), "return")]
+    [JsonDerivedType(typeof(BreakStmt), "break")]
     public abstract record Statement(int Line) : TopLevelNode(Line);
 
     [JsonPolymorphic(TypeDiscriminatorPropertyName = "expr")]
@@ -54,6 +56,7 @@ public sealed record ExprStmt(Expression Expr, int Line) : Statement(Line);
     public sealed record IfStmt(Expression Condition, Statement Then, Statement? Else, int Line) : Statement(Line);
     public sealed record WhileStmt(Expression Condition, IReadOnlyList<Statement> Body, int Line) : Statement(Line);
     public sealed record ReturnStmt(Expression? Expr, int Line) : Statement(Line);
+    public sealed record BreakStmt(int Line) : Statement(Line);
 
     [JsonPolymorphic(TypeDiscriminatorPropertyName = "member")]
     [JsonDerivedType(typeof(FieldDecl), "field")]

compiler/lexer/TokenSet.cs

@@ -28,6 +28,7 @@ public static IReadOnlyList<ITokenDefinition> Default() =>
                 {"then", TokenType.Then},
                 {"else", TokenType.Else},
                 {"return", TokenType.Return},
+                {"break", TokenType.Break},
                 {"this", TokenType.This},
                 {"true", TokenType.True},
                 {"false", TokenType.False}

compiler/lexer/TokenType.cs

@@ -34,4 +34,5 @@ public enum TokenType
     False = Boolean * 127, // false
     Eof = 131, // end of file
     LineComment = 137, // //
+    Break = 149, // break
 }

compiler/semantic/AstUtils.cs

@@ -0,0 +1,66 @@
+using MiniLang.Syntax;
+
+namespace MiniLang.Semantic;
+
+public static class AstUtils
+{
+    public static T DeepClone<T>(T node) where T : AstNode => (T)CloneAst(node);
+
+    public static TypeRef CloneTypeRef(TypeRef t)
+        => new TypeRef(t.Name, t.TypeArguments.Select(CloneTypeRef).ToList(), t.Line);
+
+    private static AstNode CloneAst(AstNode node)
+    {
+        switch (node)
+        {
+            case ProgramAst p:
+                return new ProgramAst(p.Items.Select(i => (TopLevelNode)CloneAst(i)).ToList());
+            case ClassDecl c:
+                return new ClassDecl(c.Name, c.TypeParameters.ToList(), c.BaseType != null ? CloneTypeRef(c.BaseType) : null,
+                    c.Members.Select(m => (ClassMember)CloneAst(m)).ToList(), c.Line);
+            case FieldDecl f:
+                return new FieldDecl(f.Name, (Expression)CloneAst(f.Init), f.Line);
+            case MethodDecl m:
+                return new MethodDecl(m.Name, m.Parameters.Select(p => new Parameter(p.Name, CloneTypeRef(p.Type), p.Line)).ToList(),
+                    m.ReturnType != null ? CloneTypeRef(m.ReturnType) : null,
+                    m.Body != null ? (MethodBody)CloneAst(m.Body) : null,
+                    m.IsConstructor, m.Line);
+            case BlockBody b:
+                return new BlockBody(b.Statements.Select(s => (Statement)CloneAst(s)).ToList(), b.Line);
+            case ExprBody eb:
+                return new ExprBody((Expression)CloneAst(eb.Expr), eb.Line);
+            case VarDeclStmt v:
+                return new VarDeclStmt(v.Name, (Expression)CloneAst(v.Init), v.Line);
+            case AssignStmt a:
+                return new AssignStmt((Expression)CloneAst(a.Target), (Expression)CloneAst(a.Value), a.Line);
+            case ExprStmt es:
+                return new ExprStmt((Expression)CloneAst(es.Expr), es.Line);
+            case IfStmt i:
+                return new IfStmt((Expression)CloneAst(i.Condition), (Statement)CloneAst(i.Then), i.Else != null ? (Statement)CloneAst(i.Else) : null, i.Line);
+            case WhileStmt w:
+                return new WhileStmt((Expression)CloneAst(w.Condition), w.Body.Select(s => (Statement)CloneAst(s)).ToList(), w.Line);
+            case ReturnStmt r:
+                return new ReturnStmt(r.Expr != null ? (Expression)CloneAst(r.Expr) : null, r.Line);
+            case BreakStmt br:
+                return new BreakStmt(br.Line);
+            case IdentifierExpr ie:
+                return new IdentifierExpr(ie.Name, ie.Line);
+            case ThisExpr th:
+                return new ThisExpr(th.Line);
+            case LiteralExpr le:
+                return new LiteralExpr(le.Lexeme, le.Kind, le.Line);
+            case MemberAccessExpr ma:
+                return new MemberAccessExpr((Expression)CloneAst(ma.Target), ma.Member, ma.Line);
+            case CallExpr call:
+                return new CallExpr((Expression)CloneAst(call.Target), call.Arguments.Select(a => (Expression)CloneAst(a)).ToList(), call.Line);
+            case GenericRefExpr gr:
+                return new GenericRefExpr((Expression)CloneAst(gr.Target), gr.TypeArguments.Select(CloneTypeRef).ToList(), gr.Line);
+            case IndexExpr ix:
+                return new IndexExpr((Expression)CloneAst(ix.Target), (Expression)CloneAst(ix.Index), ix.Line);
+            case ParenExpr pe:
+                return new ParenExpr((Expression)CloneAst(pe.Inner), pe.Line);
+            default:
+                throw new NotSupportedException($"Unknown AST node: {node.GetType().Name}");
+        }
+    }
+}