সরাসরি পর্বে যান
পর্ব ৫০ · ৮৬-এর মধ্যে · মডিউল ৮

Parser-এর error recovery আর ভালো diagnostic message

Parser Error Recovery and Good Diagnostic Messages

Taught in Bangla, this lesson defines a good diagnostic (location, what was expected, one primary mark) and compares Haat's messages with real Clang output. It decides which token each error points at, implements panic-mode recovery with synchronizing tokens in in-page Python (Pyodide), compares three strategies on the same broken program to show how cascades of spurious messages arise, adds error productions, tests messages with golden files and mutation fuzzing, and renders source lines with carets.

এই পর্বে যা শিখবেন

  • একটি ভালো compiler diagnostic-এর অংশগুলো, আর সত্যিকারের Clang-এর বার্তার সঙ্গে Haat-এর বার্তার তুলনা
  • কোন ভুলের দাগ কোন token-এ পড়ে, আর কেন বাদ পড়া ; আগের token-এর পরে দেখানো হয়
  • Panic mode recovery আর synchronizing token: Haat-এর reference ঠিক কোথায় থামে, কোথায় আবার শুরু করে
  • Cascade কীভাবে জন্মায়, তিনটি কৌশলের তুলনা, আর error production দিয়ে নির্দিষ্ট বার্তা
  • Error message-এর test: golden file, mutation fuzzing আর reference-এর সঙ্গে differential test

১ · ভালো diagnostic কেমন — কোথায়, কী আশা ছিল, একটি মূল দাগ

বোর্ড পরীক্ষার একজন পরীক্ষক খাতা দেখছেন। প্রথম প্রশ্নের তৃতীয় লাইনে একটি ভুল পেলেন। তিনি খাতা বন্ধ করে দেন না। ভুলের ঠিক জায়গায় লাল কালির দাগ দেন, পাশে ছোট করে লেখেন কী হওয়ার কথা ছিল, তারপর পরের প্রশ্নের নম্বরে চোখ নিয়ে আবার পড়া শুরু করেন। একটি ভুলের জন্য তিনি পরের দশটি লাইনকেও ভুল ধরেন না; প্রশ্নের নম্বরটিই তাঁর নিরাপদ জায়গা। একটি ভালো parser ঠিক এই পরীক্ষক।

এই পর্বে দুটি প্রশ্ন। প্রথমটি diagnostic নিয়ে: compiler-এর বার্তা কী বলবে আর কোথায় দাগ দেবে। দ্বিতীয়টি error recovery নিয়ে: একটি ভুলের পরে parser কীভাবে আবার পায়ের তলায় মাটি পায়, যাতে এক run-এ কয়েকটি আসল ভুল ধরা পড়ে। পর্ব ৪৭-এ Haat-এর statement parser প্রথম error-এ থেমেছিল, আর সেখানে বলা ছিল recovery এই পর্বের কাজ। এখন আমরা reference বাস্তবায়নের parser.py-এর বাকি অংশটুকু বানাব: Panic, synchronize আর সব error একসাথে সাজিয়ে দেখানো। তত্ত্বের দিক (recovery-র চার কৌশল, expected-token set, LL আর LR parser-এ recovery) গণনার তত্ত্ব কোর্সের পর্ব ৪২ (grammar design)-এ আছে; এখানে আমরা প্রকৌশলের দিকটি করব।

প্রথমে দেখি একটি পরিণত compiler কী দেখায়। নিচে বাজারঘরের দাম-হিসাবের একটি ছোট C ফাইল, যাতে তিনটি ভুল: একটি ; বাদ, একটি ) বাদ, আর একটি নামের বানান ভুল। সত্যিকারের run, লেখকের ল্যাবে PyPI-র ziglang 0.17.1-এর ভেতরের Clang 22.1.8 দিয়ে (zig-এর নিজের একটি অপ্রাসঙ্গিক warning লাইন বাদ):

$ zig cc -fsyntax-only -fno-color-diagnostics bazar.c
bazar.c:2:23: error: expected ';' at end of declaration
    2 |     int p = qty * unit
      |                       ^
      |                       ;
bazar.c:7:34: error: expected ')'
    7 |     int first = price(2, 520 + 60;
      |                                  ^
bazar.c:7:22: note: to match this '('
    7 |     int first = price(2, 520 + 60;
      |                      ^
bazar.c:8:17: error: use of undeclared identifier 'firts'
    8 |     int total = firts + 1;
      |                 ^~~~~
3 errors generated.

এই output-এ একটি ভালো diagnostic-এর প্রায় সব অংশ আছে। নিচের টেবিলে অংশগুলো, আর Haat-এর reference কোনটি রাখে:

অংশClang-এর উদাহরণHaat
অবস্থানbazar.c:2:23আছে: 2:23, code point ধরে কলাম
মাত্রা (severity)error, note, warningerror আর runtime error
বার্তা: কী আশা ছিলexpected ')'আছে: expected ')' after arguments
Source লাইন আর দাগ^, শব্দের নিচে ^~~~~নেই; অংশ ৭-এ নিজে বানাব
সংশ্লিষ্ট জায়গা (note)to match this '('নেই
সংশোধনের পরামর্শনিচে ; (fix-it)নেই

দুটি জিনিস লক্ষ করুন। এক, প্রতিটি বার্তার একটিই মূল দাগ (primary location): সমস্যা যেখানে ধরা পড়ল। “কোথায় শুরু হয়েছিল” ধরনের দ্বিতীয় জায়গা আলাদা note হয়ে আসে, মূল দাগকে ঝাপসা করে না। দুই, Clang তিনটি ভুলের পর থামেনি, আর একটি ভুলের জন্য বাড়তি কোনো বার্তা দেয়নি: ; বাদ পড়ার পরও পরের লাইনের if ঠিকঠাক পড়েছে, যেন সে নিজেই ; বসিয়ে নিয়েছে। এই দ্বিতীয় দক্ষতাটির নাম recovery, আর এই পর্বের বড় অংশ সেটি নিয়ে। একটি পার্থক্যও আছে: Clang নামের ভুলও (firts) একই run-এ বলেছে, কারণ সে parse করতে করতেই নাম খোঁজে। Haat-এ ধাপগুলো আলাদা (নকশা-সিদ্ধান্ত ২): parser-এর error থাকলে resolver আর type checker চলেই না।

বার্তার ভাষাও নকশার বিষয়। পর্ব ৩৪-এ দেখেছেন, Elm ভাষার লেখক Evan Czaplicki ২০১৫ সালের দিকে “Compiler Errors for Humans” লেখায় বার্তাকে কথোপকথনের মতো করার পক্ষে যুক্তি দেন, আর পরে Rust-সহ কয়েকটি ভাষার বার্তার ধরন এই ধারায় প্রভাবিত হয়েছে বলে প্রায়ই বলা হয়। Haat-এর reference ইচ্ছা করে ছোট, এক লাইনের ইংরেজি বার্তা রাখে, যাতে test সহজ হয় আর editor সহজে পড়তে পারে। ভালো বার্তার তিনটি পরীক্ষা মনে রাখুন: পাঠক কি দাগ দেখে এক নজরে জায়গাটি পান? বার্তা কি বলে কী আশা ছিল, শুধু “syntax error” নয়? আর বার্তাটি কি সত্যিই সেই ভুলের, নাকি আগের কোনো ভুলের ছায়া?

ছবি ৫০.১ — Haat-এর parser-এ একটি error-এর জীবনচক্র

ওপরে error ধরা আর লেখা; মাঝে panic আর synchronize-এর চারটি থামার নিয়ম; নিচে আবার parse শুরু আর শেষে সাজানো তালিকা

Life of a syntax error in the Haat parser: record, panic, synchronize with four stop rules, resume, sort fail(): error ধরা পড়ল তালিকায় (line, col, বার্তা) raise Panic statement বাদ, ফেরা except Panic: synchronize() token বাদ, depth গোনা { হলে +১, } হলে −১ ১ · depth ০-এ statement keyword let var fn if while … → এর আগে থামা ২ · depth ০-এ অমিল } → এর আগে থামা (block নেবে) ৩ · depth ০-এ ; → এর পরে থামা ৪ · পুরো { … } শেষ (১ → ০) → এর পরে থামা অগ্রগতি হলো না? তাহলে জোর করে এক token পরের statement parse নতুন ভুল হলে আবার ওপরে EOF-এ পৌঁছে সব error (line, col) ধরে সাজানো একটিও থাকলে পরের ধাপ বন্ধ
ছবি ৫০.১ — নিয়ম ১ আর ২ আগে থামে, কারণ ওই token নতুন statement শুরু করবে বা চলতি block শেষ করবে; নিয়ম ৩ আর ৪ পরে থামে, কারণ ভাঙা statement সেখানে শেষ। ভেতরের { … }-এর ; থামার জায়গা নয়। এই চারটি token-কে বলে synchronizing token.

২ · Error-এর ঠিকানা — কোন token-এ দাগ পড়বে

Parser একটি syntax error টের পায় একটি নির্দিষ্ট মুহূর্তে: সে একটি token আশা করছিল, পেল অন্য কিছু। সবচেয়ে সরল নিয়ম হলো সেই অপ্রত্যাশিত token-এর অবস্থান দেখানো, আর Haat বেশির ভাগ error-এ তা-ই করে। কিন্তু একটি জায়গায় এই নিয়ম মানুষকে বিভ্রান্ত করে: বাদ পড়া ;. নিচের লাইনে unit-এর পরে ; নেই:

    let p = qty * unit
    if p >= 1000 { return p - p / 10; }

Parser ভুলটি টের পায় পরের token if দেখে, যা লাইন ৩-এ। “3:5-এ error” বললে পাঠক লাইন ৩-এ খুঁজবেন, অথচ সেখানে কোনো ভুল নেই। তাই reference README-এর নকশা-সিদ্ধান্ত ২৪: বাদ পড়া ; জানানো হয় আগের token-এর ঠিক পরে, অর্থাৎ unit-এর কলাম ১৯ আর দৈর্ঘ্য ৪ যোগ করে 2:23; gcc আর rustc-ও এমন করে, আর ওপরের Clang-এর বার্তাতেও ঠিক 2:23. পর্ব ৪৭-এর stepper-এ এই হিসাব ধাপে ধাপে দেখেছেন। বাকি নিয়মগুলো এক টেবিলে:

Errorদাগ কোথায়উদাহরণ (reference-এর সত্যিকারের run)
বাদ পড়া ;আগের token-এর ঠিক পরেlet x = 1⏎print(x); → 1:10
অন্য বাদ পড়া tokenঅপ্রত্যাশিত token-এlet a = (1 + 2; → 1:15, ;-এ
শৃঙ্খলিত তুলনাদ্বিতীয় operator-এlet z = a < b < c; → 1:15
ভুল assignment-এর লক্ষ্য=-এ1 + 2 = 3; → 1:7
ফাইলের শেষে কিছু বাকিEOF token-এ{ বন্ধ না হলে expected '}' at end of block

শেষ সারিটি একটি পুরোনো প্রশ্ন ফিরিয়ে আনে। “ফাইলের শেষ” কোথায়? পর্ব ৪৬-এর differential test-এ একটি spec-এর ফাঁক ধরা পড়েছিল: শেষ লাইনে newline ছাড়া একটি comment থাকলে reference EOF token-কে comment-এর শুরুতে বসায়, লাইনের শেষে নয়। এই পর্বে তার ফল সরাসরি দেখা যায়, কারণ “শেষে কিছু বাকি” ধরনের প্রতিটি parser error সেই EOF-এর অবস্থানেই দাগ দেয়। Spec v1 এ বিষয়ে চুপ, আর reference-ই মাপকাঠি; নিচের পাতার lexer তাই comment-এর শুরুতেই EOF রাখে।

Haat-এর বার্তাগুলো একটি ধাঁচে লেখা: expected X after Y. “X” বলে কী আশা ছিল, “after Y” বলে কোন গঠনের ভেতরে। যা পাওয়া গেল (found), সেটি বার্তায় নেই; দাগই তা দেখায়। গণনার তত্ত্বের পর্ব ৪২-এ এর সাধারণ রূপ দেখেছেন: expected-token set, অর্থাৎ ওই অবস্থায় কোন কোন token বৈধ হতো। Recursive descent-এ সেই set হাতে লেখা প্রতিটি expect-এর ভেতরে লুকানো, আর প্রসঙ্গ (“after print statement”) বিনা খরচে আসে, কারণ প্রতিটি expect জানে সে কোন method-এর ভেতরে।

এবার কোড। নিচের block-এ পাতার parser-এর ভিত: একটি ছোট lexer আর token-এর হাতিয়ার। Lexer-টি পর্ব ৪৬-এর regex-ধাঁচের দ্বিতীয় lexer-এর ছোট রূপ; সব বৈধ Haat-এ সে reference-এর tokens-এর মতো একই kind, লেখা আর line:col দেয় (ল্যাবে reference-এর ১৩টি উদাহরণ-ফাইলেই হুবহু মিলেছে), কিন্তু অচেনা অক্ষর পেলে শুধু থামে; সঠিক lexical বার্তা পর্ব ৪৬-এর lexer-এর কাজ। Parser-এর অংশ reference-এর parser.py-এর নামে: peek, check, advance, match, expect, আর নতুন দুটি, fail আর Panic. এটি এবং পরের তিনটি Python block data-shared, অর্থাৎ একটি namespace-এ চলে, আর প্রতিটি block আগের Parser class-কে বাড়ায়। চালালে একটি ছোট পরীক্ষা: বাদ পড়া ;-এর দাগ কোথায় পড়বে।

import re, collections          # lexer: পর্ব ৪৬-এর ছোট regex রূপ; বাকিটা parser.py-র নামে
Token = collections.namedtuple("Token", "kind text line col")
OPS = dict(zip("== != <= >= && || -> + - * / % < > ! = ( ) { } , ; :".split(), """EQ_EQ BANG_EQ LT_EQ
  GT_EQ AND_AND OR_OR ARROW PLUS MINUS STAR SLASH PERCENT LT GT BANG EQ LPAREN RPAREN LBRACE RBRACE COMMA SEMI COLON""".split()))
PAT = re.compile(r'(?P<C>//.*)|(?P<W>[A-Za-z_]\w*)|(?P<INT>\d+)|(?P<STRING>"(?:\\.|[^"\\])*")'
                 r'|(?P<OP>[=!<>]=|&&|\|\||->|[-+*/%<>!=(){},;:])|(?P<BAD>\S)', re.A)
KW = set("let var fn if else while return true false print".split())
def tokenize(src):                       # কলাম = code point, ১ থেকে; শেষে EOF
    toks, lines = [], src.split("\n"); eof = len(lines[-1]) + 1
    for ln, text in enumerate(lines, 1):
        for m in PAT.finditer(text):
            k, t = m.lastgroup, m.group()
            if k == "C": eof = m.start() + 1 if ln == len(lines) else eof; break
            if k == "BAD": raise ValueError(f"{ln}:{m.start() + 1}: lexical error (পর্ব ৪৬)")
            k = OPS[t] if k == "OP" else t.upper() if t in KW else "IDENT" if k == "W" else k
            toks.append(Token(k, t, ln, m.start() + 1))
    return toks + [Token("EOF", "", len(lines), eof)]
INFIX = {k: bp for bp, ks in [(10, "OR_OR"), (20, "AND_AND"), (30, "EQ_EQ BANG_EQ"),
         (40, "LT LT_EQ GT GT_EQ"), (50, "PLUS MINUS"), (60, "STAR SLASH PERCENT")] for k in ks.split()}
PREFIX_START = {"INT", "STRING", "TRUE", "FALSE", "IDENT", "LPAREN", "MINUS", "BANG", "FN"}
STMT_START = {"LET", "VAR", "FN", "IF", "WHILE", "RETURN", "PRINT"}
class Panic(Exception): pass             # "এই statement বাদ" — সংকেত
class Parser:
    def __init__(s, toks): s.toks, s.pos, s.errors = toks, 0, []
    def peek(s, k=0): return s.toks[min(s.pos + k, len(s.toks) - 1)]
    def check(s, kind): return s.peek().kind == kind
    def advance(s): t = s.peek(); s.pos += t.kind != "EOF"; return t
    def match(s, kind): return s.check(kind) and s.advance()
    def fail(s, msg, where=None):        # error লিখে রাখা, তারপর panic
        t = s.peek(); s.errors.append((*(where or (t.line, t.col)), msg)); raise Panic
    def expect(s, kind, msg):
        if s.check(kind): return s.advance()
        p = s.toks[s.pos - 1]            # বাদ পড়া ';' দেখায় আগের token-এর ঠিক পরে (সিদ্ধান্ত ২৪)
        s.fail(msg, (p.line, p.col + len(p.text)) if kind == "SEMI" and s.pos else None)
t = tokenize("let p = qty * unit\nif")[-3]; print(t, "→ বাদ পড়া ; দেখাবে", f"{t.line}:{t.col + len(t.text)}")

আসল আউটপুট (ব্রাউজারের Python):

Token(kind='IDENT', text='unit', line=1, col=15) → বাদ পড়া ; দেখাবে 1:19

দুই লাইনের input-এর শেষ তিনটি token হলো unit, if আর EOF; [-3] তাই unit, কলাম ১৫ থেকে চার অক্ষর। ; থাকার কথা ছিল ঠিক তার পরে, কলাম ১৯-এ, যদিও parser ভুলটি দেখবে লাইন ২-এর if-এ। expect-এর শেষ দুই লাইন ঠিক এই হিসাব করে: p.col + len(p.text). লক্ষ করুন fail শুধু error লিখে রাখে না, Panic ছুড়ে দেয়। Python-এর exception এখানে একটি নিয়ন্ত্রণ-যন্ত্র: গভীরে কোথাও ভুল হলে মাঝের সব function (expression, prefix, …) একসাথে ছেড়ে দিয়ে statement-এর স্তরে ফেরা যায়, প্রতিটি function-এ আলাদা করে “ভুল হয়েছে কি?” পরীক্ষা না করেই। পর্ব ২৮-এর stack unwinding এখানে কাজে লাগছে।

৩ · Panic mode — নিরাপদ জায়গা পর্যন্ত token ফেলে দেওয়া

একটি ভুলের পরে parser-এর মাথায় যা আছে (কোন function-এ সে, কতগুলো বন্ধনী খোলা) তা আর বিশ্বাসযোগ্য নয়। সবচেয়ে পুরোনো আর এখনো সবচেয়ে প্রচলিত সমাধান panic mode recovery: চলতি গঠনটি (এখানে statement) পুরো ছেড়ে দেওয়া, তারপর input থেকে token ফেলে যাওয়া যতক্ষণ না এমন একটি token আসে যেখান থেকে নিশ্চিন্তে আবার শুরু করা যায়। Compiler-এর পরিচিত পাঠ্যবই (Aho, Sethi আর Ullman-এর “Dragon book”, ১৯৮৬) recovery-র চারটি কৌশলের প্রথমটি হিসেবে এটিকেই বলে; বাকি তিনটি phrase-level, error production আর global correction, যাদের কথা অংশ ৫-এ।

কঠিন প্রশ্ন হলো কোন token “নিরাপদ”. Haat-এর উত্তর নকশা-সিদ্ধান্ত ২৫, যা ছবি ৫০.১-এ আঁকা: একই বন্ধনী-গভীরতায় পরের ;-এর পরে, বা একটি পুরো { … }-এর পরে, বা একটি statement keyword (let var fn if while return print) বা একটি অমিল }-এর আগে। গভীরতা গোনাটাই মূল কৌশল। while-এর শর্তে ভুল হলে তার body-র ভেতরের ; থামার জায়গা নয়; সেখানে থামলে body-র বাকি অংশ আর বন্ধ } top level-এ এসে পড়ত, আর নতুন ভুয়া error জন্মাত। আর অমিল }-এর আগে থামতে হয়, কারণ সেটি বাইরের block-এর; গিলে ফেললে বাইরের block শেষ হওয়ার চিহ্ন হারায় (অনুশীলন ২)।

নিচের block-এ reference-এর দুটি method হুবহু যুক্তিতে: statements_until প্রতিটি statement-কে try-এর ভেতরে চালায় আর Panic ধরলে synchronize ডাকে; synchronize চারটি নিয়ম মেনে token ফেলে। সঙ্গে statement-এর parser, পর্ব ৪৭-এর মতোই, শুধু ঘন করে লেখা। শেষ লাইনে synchronize-কে সরাসরি একটি token-সারিতে চালানো হয়েছে।

class Parser(Parser):                # parser.py-র recovery আর statement-অংশ
    def statements_until(s, end):
        while not s.check(end) and not s.check("EOF"):
            start = s.pos
            try: s.statement()
            except Panic:                    # error লেখা হয়ে গেছে; এবার নিরাপদ জায়গা খোঁজা
                s.synchronize()
                if s.pos == start: s.advance()    # সবসময় অন্তত এক পা এগোনো
    def synchronize(s):                      # নকশা-সিদ্ধান্ত ২৫
        depth = 0
        while not s.check("EOF"):
            kind = s.peek().kind
            if depth == 0 and kind in STMT_START | {"RBRACE"}: return   # এর আগে থামা
            s.advance(); depth += (kind == "LBRACE") - (kind == "RBRACE")
            if depth == 0 and kind in ("SEMI", "RBRACE"): return        # এর পরে থামা
    def statement(s):
        k = s.peek().kind
        if k == "FN" and s.peek(1).kind == "IDENT":
            s.advance(); s.advance(); return s.function_rest("expected '(' after function name")
        if k == "LBRACE": return s.block("expected '{'")
        if s.match("IF"): return s.if_rest()
        if s.match("WHILE"): s.expression(); return s.block("expected '{' after while condition")
        if k in ("LET", "VAR"):
            kw = s.advance().text; s.expect("IDENT", f"expected variable name after '{kw}'")
            if s.match("COLON"): s.parse_type()
            s.expect("EQ", f"expected '=' after variable name in '{kw}'"); s.expression(); end = "variable declaration"
        elif s.match("RETURN"): s.check("SEMI") or s.expression(); end = "return"
        elif s.match("PRINT"):
            s.expect("LPAREN", "expected '(' after 'print'"); s.expression()
            s.expect("RPAREN", "expected ')' after print argument"); end = "print statement"
        elif s.expression() and s.match("EQ"): s.expression(); end = "assignment"  # শুধু নামে
        elif s.check("EQ"): s.fail("invalid assignment target")
        else: end = "expression"
        s.expect("SEMI", f"expected ';' after {end}")
p = Parser(tokenize("a b { c; } ; let x")); p.synchronize(); print("থামল:", p.peek())

আসল আউটপুট (ব্রাউজারের Python):

থামল: Token(kind='SEMI', text=';', line=1, col=12)

a b { c; } ; let x-এ synchronize a আর b ফেলে দেয়, {-এ গভীরতা ১ হয়, তাই ভেতরের c;-এর ;-এ থামে না। }-এ গভীরতা আবার ০, আর নিয়ম ৪ বলে একটি পুরো { … } শেষ হলে তার পরেই থামা। তাই cursor এখন দ্বিতীয় ;-এর ওপর, কলাম ১২-এ। পরের statement সেখান থেকে শুরু হবে। statements_until-এর একটি লাইন খুব জরুরি: if s.pos == start: s.advance(). Top level-এ একটি একা } থাকলে statement সেটিকে expression হিসেবে পড়তে গিয়ে ব্যর্থ হয়, আর synchronize নিয়ম ২ মেনে তার আগেই থামে; cursor এক চুলও নড়েনি। এই লাইন না থাকলে parser চিরকাল একই }-এ ঘুরত। Reference-এ }⏎print(1);-এর ফল একটিমাত্র 1:1: error: expected expression, তারপর print স্বাভাবিকভাবে পড়া হয়।

এবার পুরো ভাঙা বাজারঘর program-এর লাইন ৭-এ একটি শৃঙ্খলিত তুলনা, আর panic mode কীভাবে একটি পুরো block পার হয়ে পরের statement-এ পৌঁছায়। Program-টি অংশ ৬-এ পুরো দেখবেন; এখানে শুধু এই লাইন:

1fail(): error লেখা, raise Panic2except Panic: s.synchronize()3depth = 04while not s.check("EOF"):5  depth 0 আর keyword বা }? → আগে থামা6  s.advance(); depth হালনাগাদ7  depth 0 আর ; বা }? → পরে থামা
synchronize-এর অবস্থা
cursor
depth
কাজ
  1. ভুল ধরা। while-এর শর্ত পড়তে Pratt loop total < 5000 বানায়; এই স্তরে শেষ operator ছিল তুলনা, binding power ৪০। পরের < (7:20)-ও ৪০, তাই নকশা-সিদ্ধান্ত ১০-এর পরীক্ষা খাটে: error 7:20: comparison operators cannot be chained লেখা হয়, তারপর Panic. পাতার কোডে cursor তখন 6000-এ (operator আগেই পড়া হয়েছে); reference-এ <-এ। ফল একই, কারণ < নিজে থামার জায়গা নয়।
  2. Statement ছাড়া। Panic expression, statement পার হয়ে top level-এর statements_until-এ ধরা পড়ে। while statement-টি AST-এ যাবেই না। synchronize শুরু, depth = 0.
  3. সংখ্যা বাদ। 6000 keyword নয়, } নয়, তাই আগে থামা নেই। Token ফেলা হয়; সেটি ; বা } নয়, তাই পরেও থামা নেই।
  4. বন্ধনীতে ঢোকা। { (7:27) ফেলে দিতেই গভীরতা ১। এখন থেকে ভেতরের কিছুই থামার কারণ হবে না।
  5. ভেতরের statement বাদ। total = total + 1250-এর পাঁচটি token একে একে ফেলা হয়, গভীরতা ১-এই থাকে। Body-র এই statement-টি বৈধ ছিল, তবু বাদ পড়ল; panic mode-এর দাম এটিই: নিরাপদ জায়গার আগে যা আছে, তার ভুল আর দেখা হয় না।
  6. ভেতরের ;. ; (7:49) ফেলা হলো, কিন্তু গভীরতা ১, তাই নিয়ম ৩ খাটে না। এখানে থামলে } top level-এ পড়ত আর একটি ভুয়া expected expression জন্মাত।
  7. পুরো block শেষ। } (7:51) ফেলতেই গভীরতা ০: নিয়ম ৪, এখানেই থামা। পরের statement print(first) (8:1) থেকে parse আবার স্বাভাবিক; সেখানে শেষ ; বাদ, তাই চতুর্থ error 8:13. লেখকের ল্যাবে synchronize-এ print বসিয়ে চালানো trace-এ ঠিক এই ক্রম এসেছে।

৪ · Cascade — এক ভুল থেকে অনেক বার্তা

Recovery-র মান মাপার আসল পরীক্ষা cascading error: একটি আসল ভুলের ছায়ায় জন্মানো বাড়তি, ভুয়া বার্তা। প্রোগ্রামার প্রথম বার্তাটি ঠিক করে আবার চালালে এরা উধাও হয়, কিন্তু ততক্ষণে তাঁর সময় আর বিশ্বাস দুটিই গেছে। Cascade কমানোর দুটি সহজ কিন্তু ভুল পথ আছে: ভুলের জায়গা থেকেই সঙ্গে সঙ্গে আবার শুরু করা, আর প্রথম ভুলের পরে ফাইলের বাকিটা ফেলে দেওয়া। ল্যাবে reference-এর Parser-এর দুটি subclass বানিয়ে (শুধু synchronize বদলে) একই ভাঙা program-এ তিন কৌশল চালানো হয়েছে; ফল নিচের stepper-এ।

6let first = price(2, 520 + delivery(60;7while total < 5000 < 6000 { … }8print(first)2if total >= 1000 return 0; } else { … }
কৌশল আর হিসাব
কৌশল
cursor
বার্তা
  1. একই শুরু। লাইন ২-এর বাদ পড়া ; (2:23) আগেই লেখা। লাইন ৬-এ delivery(60-এর পরে ) নেই: arguments-এর তালিকা ;-এ এসে আটকায়, error 6:39: expected ')' after arguments. এ পর্যন্ত তিন কৌশলই এক।
  2. Panic mode. synchronize গভীরতা ০-এ ; দেখে সেটি ফেলে থামে (নিয়ম ৩)। পরের statement while থেকে, পরিষ্কারভাবে। বাড়তি কোনো বার্তা নেই।
  3. সঙ্গে সঙ্গে আবার শুরু। synchronize কিছুই না ফেললে নতুন statement শুরু হয় ঠিক সেই ;-এ, যা কোনো expression-এর শুরু হতে পারে না: 6:39: expected expression. একই কলামে দুটি বার্তা, দ্বিতীয়টি পুরো ভুয়া। অগ্রগতি না হওয়ায় তারপর এক token এগোনো হয়।
  4. Cascade বাড়ে। লাইন ৭-এ শৃঙ্খলিত তুলনার পরে (reference-এ cursor <-এর ওপর) নতুন statement শুরু হয় < থেকে: 7:20-এ আবার expected expression. তারপর 6000 একটি expression statement হিসেবে পড়া হয়, যার পরে ; নেই: 7:26: expected ';' after expression. তিনটি আসল ভুল থেকে এ পর্যন্ত মোট ছয়টি বার্তা।
  5. হিসাব। চারটি আসল ভুলের জন্য panic mode দেয় ঠিক ৪টি বার্তা। তাৎক্ষণিক শুরু দেয় ৭টি (৩টি ভুয়া)। আর প্রথম ভুলের পরে ফাইলের শেষ পর্যন্ত সব ফেলে দিলে ২টি: 2:23 আর 9:1: expected '}' at end of block. দ্বিতীয়টি ভুয়া (ফাংশনের } ফেলে দেওয়া হয়েছে), আর আসল তিনটি ভুল হারিয়ে গেল। সব সংখ্যা ল্যাবের সত্যিকারের run.
  6. Panic mode-এর সীমা। অন্য একটি ফাইলে delivery-র ভেতরে if-এর পরে { নেই। Reference বলে 2:22: expected '{' after if condition, তারপর return 0; পড়ে, আর }-কে ফাংশনের শেষ ভাবে! ফলে else (2:34) আর শেষ } (3:1) top level-এ এসে আরও দুটি expected expression. একটি ভুল, তিনটি বার্তা: বন্ধনী হারালে গভীরতার হিসাবই ভুল হয়ে যায়, আর কোনো token-ভিত্তিক নিয়ম তা পুরো সারাতে পারে না।

শেষ ধাপটি একটি সৎ সীমা। বাস্তব compiler বন্ধনীর ভুলে আরও চালাক কৌশল নেয়: indentation দেখে কোন } কোন {-এর অনুমান করা, বা Clang-এর মতো note: to match this '(' দিয়ে খোলা বন্ধনীর জায়গা দেখানো। Cascade শুধু parser-এর সমস্যাও নয়। ভাঙা program-টির syntax ঠিক করলে reference-এর resolver বলে:

$ python -B haat.py check bazar_fixed.haat
6:28: error: undefined variable 'delivery'
7:7: error: undefined variable 'total'
7:22: error: undefined variable 'total'
7:30: error: undefined variable 'total'

একটি অনুপস্থিত var total = 0;, তিনটি বার্তা, প্রতিটি ব্যবহারের জন্য একটি। এটি resolver-এর স্তরের cascade; পর্ব ৫১ (Symbol table আর name resolution)-এ এমন নামের জন্য প্রথম বার্তার পরে একটি “error binding” রেখে বাকিগুলো চুপ রাখার কৌশল ভাবার মতো। Type checker-এ একই কাজ করে একটি বিশেষ “error type”, যা সবখানে মেনে নেওয়া হয়; পর্ব ৩৪-এর শেষ ভাবনার প্রশ্নে এর কথা আছে।

৫ · পুরো recovering parser, আর error production

বাকি grammar এবার। নিচের block-এ block, if_rest, function_rest, parse_type আর Pratt expression, reference-এর একই বার্তা আর একই binding power-এ (পর্ব ৪৭ আর পর্ব ৪৮-এর বিষয়, এখানে সংক্ষেপে)। একটি জিনিস লক্ষ করুন: expression শুধু parse করে না, ফেরত দেয় “পুরো expression কি একটি নাম মাত্র?”. Statement-এর parser এটি দিয়ে x = … আর 1 + 2 = 3-কে আলাদা করে। এটি AST বানায় না; error খোঁজার জন্য AST লাগে না, তাই কোড ছোট রাখা গেছে। পুরো AST-সহ রূপ reference-এর parser.py (২৭৮ লাইন) আর পর্ব ৪৯-এ।

class Parser(Parser):                # parser.py-র বাকিটা: block, if, function, type, Pratt
    def block(s, msg):
        s.expect("LBRACE", msg); s.statements_until("RBRACE"); s.expect("RBRACE", "expected '}' at end of block")
    def if_rest(s):
        s.expression(); s.block("expected '{' after if condition")
        if s.match("ELSE"): s.if_rest() if s.match("IF") else s.block("expected '{' or 'if' after 'else'")
    def function_rest(s, msg):
        s.expect("LPAREN", msg); more = not s.check("RPAREN")
        while more:
            p = s.expect("IDENT", "expected parameter name"); s.expect("COLON", f"expected ':' and a type after parameter '{p.text}'")
            s.parse_type(); more = s.match("COMMA")
        s.expect("RPAREN", "expected ')' after parameters"); s.match("ARROW") and s.parse_type()
        s.block("expected '{' before function body")
    def parse_type(s):
        t = s.peek()
        if t.kind == "IDENT" and t.text not in ("Int", "Bool", "Str", "Unit"): s.fail(f"unknown type '{t.text}'")
        if t.kind not in ("IDENT", "LPAREN"): s.fail("expected a type")
        if s.advance().kind == "IDENT": return
        more = not s.check("RPAREN")                    # (T1, T2) -> R
        while more: s.parse_type(); more = s.match("COMMA")
        s.expect("RPAREN", "expected ')' in function type")
        s.expect("ARROW", "expected '->' in function type"); s.parse_type()
    def expression(s, min_bp=0):                        # ফেরত: পুরোটা কি শুধু একটি নাম?
        name, last = s.prefix(), None
        while s.check("LPAREN") or INFIX.get(s.peek().kind, -1) >= min_bp:
            t, name = s.advance(), False
            if t.kind == "LPAREN":                      # call: postfix, bp 80
                more = not s.check("RPAREN")
                while more: s.expression(); more = s.match("COMMA")
                s.expect("RPAREN", "expected ')' after arguments"); continue
            if last == INFIX[t.kind] and last in (30, 40):    # নকশা-সিদ্ধান্ত ১০
                s.fail("comparison operators cannot be chained", (t.line, t.col))
            last = INFIX[t.kind]; s.expression(last + 1)
        return name
p = Parser(tokenize("(Int, Bool) -> Int {")); p.parse_type(); print("type-এর পরে:", p.peek())

আসল আউটপুট (ব্রাউজারের Python):

type-এর পরে: Token(kind='LBRACE', text='{', line=1, col=20)

parse_type পুরো function type (Int, Bool) -> Int পড়ে {-এর ঠিক আগে থামে, কলাম ২০-এ। ভেতরে সে নিজেকেই তিনবার ডাকে: Int, Bool আর ফেরার type Int-এর জন্য। এই block-এর error-গুলোর দিকে তাকান: unknown type 'X', expected a type, comparison operators cannot be chained. শেষেরটি অংশ ২-এর টেবিলের সেই বিশেষ বার্তা। এর পেছনের কৌশলের নাম নিচে।

Error production — চেনা ভুলের জন্য আলাদা পথ

একটি সাধারণ parser a < b < c-তে কী বলত? Grammar-এ তুলনা non-associative হলে a < b-এর পরে দ্বিতীয় < অপ্রত্যাশিত, তাই হয়তো “expected ';' after expression”. সত্য, কিন্তু অকেজো: প্রোগ্রামার আসলে গণিতের মতো লিখতে চেয়েছিলেন। Reference তাই Pratt loop-এ দ্বিতীয় তুলনাটিকে আগে মেনে নেয়, তারপর চিনে নির্দিষ্ট বার্তা দেয়। একে বলে error production: পরিচিত ভুলের জন্য ইচ্ছা করে রাখা একটি নিয়ম। invalid assignment target-ও একই ধাঁচের: parser পুরো 1 + 2 expression হিসেবে পড়ে, তারপর = দেখে বলে লক্ষ্যটি একটি নাম হতে হবে। অনুশীলন ১-এ আপনি নিজে একটি যোগ করবেন: if total = 0 {, যেখানে reference এখন শুধু বলে expected '{' after if condition.

Recovery-র বাকি দুটি ধ্রুপদি কৌশল সংক্ষেপে। Phrase-level recovery ভুলের জায়গায় ছোট একটি সংশোধন করে নেয়, যেমন একটি token বসানো বা মোছা, তারপর এগোয়। Clang-এর ; fix-it ঠিক এটি: সে মনে মনে ; বসিয়ে পরের লাইন পড়েছে, আর বার্তার নিচে সেই fix-it hint দেখিয়েছে। Global correction সবচেয়ে কম সম্পাদনায় input-কে বৈধ করার চেষ্টা করে; তত্ত্বে সুন্দর, বাস্তবে ব্যয়বহুল। Yacc আর Bison-এর মতো LR generator-এ grammar-এর ভেতরে একটি বিশেষ error token লেখা যায়, যা panic mode আর error production-কে মেলায়; বিস্তারিত তত্ত্বের পর্ব ৪২-এ।

৬ · বার্তার test — golden file আর mutation fuzzing

Error message ব্যবহারকারীর সঙ্গে একটি চুক্তি: editor তা পড়ে দাগ দেয়, script তা খুঁজে দেখে, আর মানুষ শব্দগুলো মুখস্থ করে ফেলে। তাই বার্তা বদলানো মানে আচরণ বদলানো, আর তার test লাগে। সবচেয়ে সরল আর সবচেয়ে শক্তিশালী উপায় golden file: একটি ভাঙা program-এর পাশে তার প্রত্যাশিত পুরো output একটি ফাইলে রাখা, আর প্রতিবার হুবহু মেলানো। Reference-এর examples/err_syntax.out ঠিক এমন একটি ফাইল, চারটি error-এর লাইন। এর জোর দেখতে ল্যাবে reference-এর একটি কপিতে একটি বার্তা একটু বদলানো হলো (expected ';' after print statement → missing ';' after print), তারপর test চালানো হলো। সত্যিকারের run, CPython 3.14.4, output ছেঁটে:

$ python -B -m unittest discover -s tests
FAIL: test_recovery_reports_several_errors (test_front.ParserTest...)
-  "6:13: error: missing ';' after print"]
+  "6:13: error: expected ';' after print statement"]
FAIL: test_golden_outputs (test_run.ExamplesTest...) (name='err_syntax.haat')
-  "6:13: error: missing ';' after print"]
+  "6:13: error: expected ';' after print statement"]
Ran 32 tests in 0.703s
FAILED (failures=2)

মূল reference-এ একই command-এর ফল Ran 32 tests … OK. একটি শব্দ বদলাতেই দুটি test লাল। Golden file সঠিকতা প্রমাণ করে না (নতুন বার্তাটি হয়তো ভালোই), শুধু বদল ধরে; বদলটি ইচ্ছাকৃত হলে মানুষ দেখে ফাইলটি হালনাগাদ করেন। এই ধারণা Software Testing কোর্সের পর্ব ৬১ (snapshot আর approval testing)-এ বিস্তারিত; সেখানে একে snapshot testing বলা হয়।

Golden file হাতে লেখা ভুলগুলোকেই পরীক্ষা করে। মানুষ যে ভুল কল্পনা করেননি, তার জন্য fuzzing. Parser-এর জন্য সবচেয়ে কাজের রূপ mutation-based fuzzing: একটি program-এর token এলোমেলোভাবে মোছা, দ্বিগুণ করা বা অন্য token দিয়ে বদলানো। পরীক্ষার মাপকাঠি (test oracle) তিনটি: parser কখনো crash করবে না (Python exception নয়, শুধু Haat error), প্রতিটি error-এর অবস্থান source-এর ভেতরে থাকবে, আর সম্ভব হলে একটি দ্বিতীয় বাস্তবায়নের সঙ্গে হুবহু মিলবে। নিচের block-এ Pratt-এর prefix অংশ (৩৫ লাইনের সীমার জন্য এখানে), তারপর parse, অংশ ৩ আর ৪-এর ভাঙা বাজারঘর program, আর ৩,০০০টি mutant-এর fuzzer, seed 50 দিয়ে।

import random
class Parser(Parser):                # Pratt-এর prefix-অংশ (expression এটিকে ডাকে)
    def prefix(s):
        if s.peek().kind not in PREFIX_START: s.fail("expected expression")
        t = s.advance()
        if t.kind == "LPAREN": n = s.expression(); s.expect("RPAREN", "expected ')' after expression"); return n
        if t.kind in ("MINUS", "BANG"): s.expression(70)
        if t.kind == "FN": s.function_rest("expected '(' after 'fn'")
        return t.kind == "IDENT"
def parse(src):
    p = Parser(tokenize(src)); p.statements_until("EOF")
    return sorted(p.errors, key=lambda e: e[:2])      # অবস্থান ধরে সাজানো (সিদ্ধান্ত ২)
SRC = """fn price(qty: Int, unit: Int) -> Int {
    let p = qty * unit
    if p >= 1000 { return p - p / 10; }
    return p;
}
let first = price(2, 520 + delivery(60;
while total < 5000 < 6000 { total = total + 1250; }
print(first)"""
for line, col, msg in parse(SRC): print(f"{line}:{col}: error: {msg}")
rng, base, runs, crashes, errors, outside = random.Random(50), tokenize(SRC)[:-1], 0, 0, 0, 0
for trial in range(3000):
    toks = list(base)
    for _ in range(rng.randint(1, 3)):                # ১–৩টি এলোমেলো বদল
        i, op = rng.randrange(len(toks)), rng.choice(["del", "dup", "new"])
        if op == "del": del toks[i]
        elif op == "dup": toks.insert(i, toks[i])
        else: toks[i] = toks[i]._replace(text=rng.choice(base).text)
    lines = [" ".join(t.text for t in toks if t.line == n) for n in range(1, 9)]
    try: found = parse("\n".join(lines))
    except Exception as e: crashes += 1; print("crash:", repr(e)); continue
    runs, errors = runs + 1, errors + len(found)
    outside += sum(not (1 <= l <= 8 and 1 <= c <= len(lines[l - 1]) + 1) for l, c, _ in found)
print(f"{runs} run, {crashes} crash, {errors} error, অবস্থান সীমার বাইরে: {outside}")

আসল আউটপুট (ব্রাউজারের Python):

2:23: error: expected ';' after variable declaration
6:39: error: expected ')' after arguments
7:20: error: comparison operators cannot be chained
8:13: error: expected ';' after print statement
3000 run, 0 crash, 13400 error, অবস্থান সীমার বাইরে: 0

প্রথম চার লাইন এক run-এ চারটি আলাদা ভুল, অবস্থান ধরে সাজানো (নকশা-সিদ্ধান্ত ২)। একই program ফাইলে রেখে reference চালালে হুবহু একই চার লাইন আসে, সত্যিকারের run:

$ python -B haat.py check bazar_broken.haat
2:23: error: expected ';' after variable declaration
6:39: error: expected ')' after arguments
7:20: error: comparison operators cannot be chained
8:13: error: expected ';' after print statement

শেষ লাইন fuzzer-এর: ৩,০০০টি mutant-এর সবগুলোতে parser শেষ পর্যন্ত চলেছে, একটিও Python exception নেই, মোট ১৩,৪০০টি error (গড়ে প্রায় সাড়ে চারটি), আর একটিরও অবস্থান source-এর বাইরে নয়। Seed নির্দিষ্ট, তাই আপনার ব্রাউজারেও একই সংখ্যা আসবে। Mutant-গুলো লাইন ঠিক রেখে token-গুলো এক space দিয়ে জোড়া দিয়ে বানানো, তাই কলামগুলো মূল program-এর চেয়ে আলাদা, কিন্তু প্রতিটি কলাম সেই নতুন লেখার ভেতরে থাকতেই হবে।

Crash না হওয়া যথেষ্ট নয়; বার্তা আর অবস্থান কি ঠিক? এর জন্য ল্যাবে পাতার চারটি block আর reference-এর parser.py-এর মধ্যে differential test চালানো হয়েছে, সত্যিকারের run:

$ python -B difftest.py
examples identical: 13 / 13
b4 mutants vs reference: 3000 same 0 diff; ref errors 13400 clean 0
mutants of 13 examples (seed 2026): 20000 same, 0 diff, 52900 errors
random token soup (1-30 tokens): 20000 same, 0 diff

চারটি স্তর। (১) Reference-এর ১৩টি উদাহরণ-ফাইল: token আর error দুটিই হুবহু। (২) ওপরের block-এর ৩,০০০টি mutant, একই seed-এ নতুন করে বানিয়ে reference-কে দেওয়া; লক্ষ করুন clean 0: কোনো mutant-ই ভুলমুক্ত হয়নি, কারণ মূল program-টিই ভাঙা। (৩) ১৩টি উদাহরণের প্রতিটি থেকে ১–৪টি বদলে (মোছা, দ্বিগুণ, বদল, পাশের token-এর সঙ্গে অদলবদল) ২০,০০০টি mutant. (৪) ১ থেকে ৩০টি এলোমেলো token-এর ২০,০০০টি “token-স্যুপ”.

মোট ৪৩,০১৩টি input-এ প্রতিটি error-এর বার্তা, line আর col দুটি parser-এ হুবহু এক, ক্রমসহ। এই সংখ্যা ছোট কোডটির ওপর আস্থা দেয়, যদিও প্রমাণ নয়; পর্ব ৪৭-এ দেখেছেন, random test কিছু সীমার ঘটনা (শেষে কমা) সহজে ধরে না। Fuzzing আরেকটি জিনিস মনে করায়: গভীরতা। Reference-এ let x = -এর পরে ১৯,৯৯০ জোড়া বন্ধনী ঠিকঠাক চলে, কিন্তু ২০,০০০ জোড়ায় Haat error নয়, Python-এর RecursionError (লেখকের ল্যাবে সত্যিকারের run; reference-এর interp.py recursion-এর সীমা বাড়িয়ে রাখে বলে সংখ্যাটি এত বড়)। Recursive descent-এর এই গভীরতার সীমা আর তার নিরাপত্তার দিক পর্ব ৪৭-এ আলোচিত; একটি parser-এর নিজের সীমা রেখে পরিষ্কার error দেওয়া উচিত। Fuzzing-এর পুরো পদ্ধতি Software Testing কোর্সের পর্ব ৬০-এ।

৭ · দাগ আঁকা — source লাইন, caret আর range

Haat-এর এক লাইনের বার্তা যন্ত্রের জন্য যথেষ্ট, মানুষের জন্য নয়। একটি ছোট renderer বানানো যাক, যা Clang-এর মতো source লাইন আর তার নিচে দাগ আঁকে: ^ ঠিক কলামে, আর token-টি লম্বা হলে বাকি দৈর্ঘ্যে ~. প্রথাটি পুরোনো: Clang শুরু থেকেই একে “expressive diagnostics” হিসেবে প্রচার করেছিল, আর GCC-তে caret ২০১৩ সালের দিকে (GCC 4.8) আসে বলে জানা যায়। নিচের function পাতার tokenize ব্যবহার করে; চালানো যায় এমন block-এর সংখ্যা সীমিত বলে এটি ল্যাবে চালানো, output হুবহু:

def render(src, toks, line, col, msg):
    text = src.split("\n")[line - 1]
    width = next((len(t.text) for t in toks if (t.line, t.col) == (line, col) and t.text), 1)
    pad = " " * len(str(line))
    return "\n".join([f"{line}:{col}: error: {msg}",
                      f"{line} | {text}",
                      f"{pad} | {' ' * (col - 1)}^{'~' * (width - 1)}"])
$ python -B render_demo.py      # totl.haat: var total = 936;⏎print(totl + 60);
2:7: error: undefined variable 'totl'
2 | print(totl + 60);
  |       ^~~~

বার্তাটি resolver-এর (reference-এর check-এর সত্যিকারের output 2:7: error: undefined variable 'totl'), কিন্তু renderer-এর কাছে সব error একই: শুধু (line, col, বার্তা). প্রতিটি ধাপ নিচের stepper-এ।

1text = src.split("\n")[line - 1]2width = token-এর দৈর্ঘ্য, না থাকলে 13pad = " " * len(str(line))4f"{line}:{col}: error: {msg}"5f"{line} | {text}"6f"{pad} | {' ' * (col - 1)}^{'~' * (width - 1)}"
render-এর হিসাব
line, col
width
পরের অংশ
  1. উপকরণ। Error-টি (2, 7, "undefined variable 'totl'"). Source-এর লাইন ২ বের করা হয়: print(totl + 60);. লাইন নম্বর এক অঙ্কের, তাই pad একটি space; এটি বাঁয়ের দাগ-স্তম্ভটিকে (gutter) লাইন নম্বরের সমান চওড়া রাখে।
  2. শিরোনাম। প্রথম লাইন হুবহু Haat-এর এক লাইনের বার্তা। ফলে যে tool আগে থেকে line:col: error: খোঁজে (editor-এর problem matcher, CI-এর script), সে এখনো কাজ করে।
  3. Source লাইন। 2 | -এর পরে লাইনটি যেমন আছে তেমন। পাঠককে আর ফাইল খুলে লাইন ২ খুঁজতে হয় না।
  4. দাগ। col - 1 = ৬টি space, তারপর ^. Token-তালিকায় 2:7-এ একটি token আছে, totl, দৈর্ঘ্য ৪; তাই ^-এর পরে তিনটি ~. দাগ এখন পুরো নামটির নিচে, শুধু প্রথম অক্ষরে নয়।
  5. Range কেন। Caret বলে “এখানে”, range বলে “এই পুরোটা”. নামের ভুলে পুরো নাম দাগানো স্বাভাবিক; Clang-ও firts-এর নিচে ^~~~~ দেখিয়েছিল। একটি source position-এর বদলে span (শুরু আর শেষ) রাখলে compiler নিজেই range জানত; Haat শুধু শুরু রাখে, তাই renderer token থেকে দৈর্ঘ্য খুঁজে নেয়।
  6. বাদ পড়া ;. 2:23-এ কোনো token নেই (এটি unit-এর পরের ঘর), তাই width ১: একা ^, লাইনের শেষের ঠিক পরে। Clang এখানে আরও একটি লাইনে ; লিখে দেখিয়েছিল কী বসাতে হবে; Haat-এর renderer-এ সেই fix-it যোগ করা একটি সহজ বর্ধন, কারণ বার্তা নিজেই বলে কোন token আশা ছিল।

বাংলা লেখার নিচে দাগ। Haat-এর কলাম code point ধরে (নকশা-সিদ্ধান্ত ১)। let s = "দুধ"; let n = 5-এ reference-এর বার্তা 1:25: error: expected ';' after variable declaration, যা code point গুনে সঠিক। কিন্তু “দুধ”-এর ু একটি combining mark (Unicode category Mn, Python-এর unicodedata দিয়ে যাচাই করা): এটি আগের অক্ষরের সঙ্গে বসে, সাধারণত terminal-এ আলাদা ঘর নেয় না। তাই ওপরের renderer ২৪টি space দিলে দাগ পর্দায় এক ঘর ডানে সরে যেতে পারে। কলাম গোনার একক আর পর্দার প্রস্থ আলাদা জিনিস; ভাবনার প্রশ্ন ৫-এ এর আলোচনা।

আরও গভীরে: Editor-এর জন্য লেখা parser-গুলো আরও এক ধাপ যায়। Tree-sitter ভাঙা input থেকেও সবসময় একটি পুরো syntax tree দেয়, যার ভেতরে ERROR আর MISSING node থাকে; C#-এর Roslyn compiler-ও “missing” token আর বাদ দেওয়া token-কে tree-তে রেখে দেয়, যাতে tree থেকে আবার হুবহু source ফেরত আসে। এতে টাইপ করার মাঝপথে, ফাইল প্রায় সবসময় ভাঙা থাকা অবস্থাতেও রং, autocomplete আর বাকি অংশের error চলে। পর্ব ৮০ (Language tooling — LSP, formatter, linter আর incremental compilation)-এ এই error-tolerant parsing আবার আসবে।

পরীক্ষা ও ইন্টারভিউতে: এই প্রশ্নগুলো বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় প্রায়ই আসে।

  • Error recovery-র চারটি কৌশল কী? Panic mode, phrase-level, error production, global correction.
  • Synchronizing token কী? যে token পর্যন্ত input ফেলে parser আবার স্বাভাবিক কাজে ফেরে, যেমন ;, } বা statement keyword.
  • Panic mode-এর সুবিধা আর অসুবিধা? সরল আর কখনো অসীম loop-এ পড়ে না (অগ্রগতির নিয়ম থাকলে); কিন্তু বাদ পড়া অংশের ভুল দেখে না, আর বন্ধনীর ভুলে cascade দিতে পারে।
  • বাদ পড়া ; কোথায় দেখানো উচিত? আগের token-এর ঠিক পরে, কারণ পরের token হয়তো পরের লাইনে।
  • Cascading error কী, কীভাবে কমাবেন? একটি ভুলের ছায়ায় জন্মানো ভুয়া বার্তা; ভালো synchronization, error type বা error node, আর একই জায়গায় দ্বিতীয় বার্তা চেপে রাখা।

৮ · AI-এর যুগে parser-এর error handling

AI assistant একটি parser-এ “সুন্দর error message আর recovery যোগ করো” অনুরোধে দ্রুত কোড দেয়, আর সেই কোড প্রায়ই প্রথম উদাহরণে কাজ করে। সমস্যা দেখা দেয় ভাঙা input-এর অদ্ভুত কোণে, যেখানে কেউ তাকায় না। এই বিষয়ে AI-এর লেখায় যা প্রায়ই দেখা যায়:

AI-এর ভুলকীভাবে ধরবেন
synchronize-এ গভীরতা না গোনা, তাই ভেতরের ;-এ থেমে ভুয়া errorwhile a < b < c { x = 1; } চালান; বার্তা ঠিক একটি হওয়ার কথা
অগ্রগতির নিয়ম ভুলে যাওয়া, ফলে একা }-এ অসীম loopশুধু }, শুধু ), ফাঁকা ফাইল দিয়ে সময়সীমাসহ চালান
বাদ পড়া ; পরের token-এ দেখানো, বা কলাম ০ থেকে গোনাদুই লাইনের input-এ line:col হাতে গুনে মেলান
“Python বা C-তে এমন হয়” বলে এক ভাষার error-আচরণ আরেক ভাষায় চাপানোপ্রতিটি দাবির জন্য সেই ভাষার আসল compiler আর version চালান
অস্তিত্বহীন compiler flag বা বার্তা উদ্ধৃত করাFlag-টি আসল clang/gcc-এ চালিয়ে দেখুন; বার্তা নিজের run থেকে কপি করুন
Error-এর তালিকা না সাজানো, বা একই জায়গার duplicate রাখাReference বা golden file-এর সঙ্গে পুরো output হুবহু মেলান

AI-কে recovery লিখতে বললে নিয়ম, নাম আর পরীক্ষাগুলো প্রশ্নেই দিয়ে দিন:

আমি Haat নামের একটি ছোট ভাষার recursive descent parser-এ (Python) panic mode recovery যোগ করছি। নিয়ম: statement-এ error হলে Panic exception; statements_until সেটি ধরে synchronize ডাকে; synchronize token ফেলে যতক্ষণ না একই গভীরতায় ; (এর পরে থামা), একটি পুরো { … } শেষ (এর পরে), statement keyword let var fn if while return print (এর আগে) বা অমিল } (এর আগে) আসে; অগ্রগতি না হলে এক token এগোবে। বাদ পড়া ; দেখাবে আগের token-এর ঠিক পরে। সব error শেষে (line, col) ধরে সাজিয়ে "line:col: error: বার্তা" আকারে দাও। ১. synchronize আর statements_until লেখো, প্রতিটি লাইনের পাশে কোন নিয়ম তা লেখো। ২. নিচের তিনটি input-এর প্রত্যাশিত output আলাদা করে লেখো: "while a < b < c { x = 1; }", "}", আর "let x = 1" (শেষে ; নেই)। ৩. এমন একটি input দাও যেখানে তোমার recovery একটি ভুয়া বার্তা দেবে, আর কারণ ব্যাখ্যা করো। আমি তোমার output আমার reference-এর সঙ্গে মিলিয়ে দেখব।

AI-এর লেখা recovery হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন — তারপর “→ উত্তর” চাপুন।

প্র ০১একটি compiler কি সব error দেখাবে, নাকি কয়েকটির পরে থামবে?

Punch card-এর যুগে প্রশ্নটির উত্তর সহজ ছিল। একজন প্রোগ্রামার কার্ডের গোছা জমা দিতেন, আর ফল পেতেন ঘণ্টা বা দিন পরে। সেই এক run-এ যত বেশি ভুল জানা যায়, তত কম দিন নষ্ট। তাই সেই সময়ের compiler-গুলো recovery-তে অনেক যত্ন নিত, আর error recovery-র গবেষণাও তখন থেকেই। আজ একটি run কয়েক মিলিসেকেন্ডের, editor টাইপ করতে করতেই parser চালায়। তাহলে কি একটি error-ই যথেষ্ট?

বাস্তব উত্তর মাঝামাঝি। লেখকের ল্যাবে Clang 22.1.8-কে ২৫টি অঘোষিত নামের একটি C ফাইল দিলে সে ১৯টি error দেখায়, তারপর লেখে fatal error: too many errors emitted, stopping now [-ferror-limit=], আর শেষে “20 errors generated”. অর্থাৎ Clang ইচ্ছা করে একটি সীমা রাখে; option দিয়ে তা বদলানো যায়। কারণ সহজ: প্রথম কয়েকটি বার্তা সাধারণত আসল, পরেরগুলোর মধ্যে cascade-এর ভাগ বাড়তে থাকে, আর শত শত লাইনের output-এ আসল ভুল চাপা পড়ে।

Haat-এর reference একটি অন্য মাঝামাঝি পথ নেয়। Lexer প্রথম ভুলে থামে, কারণ একটি ভাঙা string বা অচেনা অক্ষরের পরে token-এর সীমাই অনিশ্চিত (পর্ব ৪৬)। Parser সব syntax error দেখায়, কিন্তু parser-এর একটি error থাকলেও resolver আর type checker চলে না (নকশা-সিদ্ধান্ত ২)। কারণ একটি ভাঙা AST-এর ওপর নাম আর type খুঁজলে cascade বহুগুণ হতো: বাদ পড়া statement-এর variable “অঘোষিত” হয়ে যেত। Clang অন্য পথে গেছে, parse আর semantic বিশ্লেষণ একসাথে করে, তাই অংশ ১-এর output-এ syntax আর নামের ভুল একসাথে এসেছিল; এর দাম হলো প্রতিটি semantic নিয়মকে ভাঙা গাছ সামলানো শিখতে হয়।

তাই নকশার প্রশ্নগুলো এমন: কোন ধাপের error কতটা বিশ্বাসযোগ্য? একটি ধাপের ভুল পরের ধাপে কতটা ছড়ায়? আর পাঠক কতগুলো বার্তা একসাথে পড়তে পারেন? Batch compiler, editor আর শেখার ভাষার উত্তর আলাদা হতে পারে।

মূল উপলব্ধি: “কতগুলো error” একটি নকশা-সিদ্ধান্ত। আসল লক্ষ্য সংখ্যা নয়, বিশ্বাসযোগ্যতা: প্রতিটি দেখানো বার্তা যেন একটি আসল ভুলের, আর সীমার পরে থামাই সৎ আচরণ।

প্র ০২Panic mode এত পুরোনো আর এত সরল; তবু আজও কেন প্রায় সব হাতে লেখা parser-এ এটিই?

Recovery-র কৌশলগুলোকে একটি মাপকাঠিতে সাজানো যায়: ভুলের পরে parser কতটা “বুদ্ধি” খাটায়। এক প্রান্তে global correction: সবচেয়ে কম সংখ্যক token বসিয়ে বা মুছে পুরো input-কে বৈধ করা। তত্ত্বে এটি সবচেয়ে সুন্দর, কারণ ফলটি একটি নির্দিষ্ট অর্থে “সবচেয়ে কাছের বৈধ program”. কিন্তু এর খরচ বেশি, আর সবচেয়ে কম সম্পাদনা সবসময় প্রোগ্রামারের উদ্দেশ্য নয়: একটি বাদ পড়া } ফাইলের অনেক জায়গায় বসানো যায়, আর গণিত বলে না কোনটি তিনি চেয়েছিলেন।

মাঝে phrase-level recovery: শুধু ভুলের জায়গায় ছোট সংশোধন। Clang-এর ; fix-it এর ভালো উদাহরণ, আর এর মান নির্ভর করে অনুমানের মানের ওপর। Error production আরও সংকীর্ণ: শুধু চেনা ভুলগুলোর জন্য নির্দিষ্ট পথ। আর panic mode অন্য প্রান্তে: কোনো অনুমান নয়, শুধু “এই statement বাদ, পরেরটি থেকে”.

Panic mode টিকে আছে তিনটি গুণে। প্রথমত, এটি সহজে সঠিক করা যায়: Haat-এর synchronize ছয় লাইনের, আর তার আচরণ চারটি নিয়মে বলা যায়। দ্বিতীয়ত, এর একটি পরিষ্কার নিশ্চয়তা আছে: অগ্রগতির নিয়ম থাকলে parser সবসময় শেষ হয় (অনুশীলন ৪)। তৃতীয়ত, ভাষার নকশাই একে সাহায্য করে। যেসব ভাষায় statement keyword দিয়ে শুরু হয় আর ; বা } দিয়ে শেষ হয়, সেখানে নিরাপদ জায়গা প্রচুর। Haat-এর let var fn if while return print ঠিক এই কাজ করে।

তত্ত্বের দিক থেকে LL(1) parser-এ synchronizing token প্রায়ই কোনো variable-এর FOLLOW set থেকে বাছা হয় (গণনার তত্ত্ব কোর্সের পর্ব ৩৮ আর ৪২)। হাতে লেখা parser-এ সেটি হাতে বাছা হয়, ভাষা জেনে। Haat-এর তালিকা ছোট, কিন্তু প্রতিটি নিয়মের পেছনে একটি কারণ আছে, যা অংশ ৩-এ দেখেছেন। বাস্তব compiler প্রায়ই panic mode-এর ভিত রেখে ওপরে কয়েকটি phrase-level সংশোধন আর error production যোগ করে।

মূল উপলব্ধি: সবচেয়ে চালাক recovery সবসময় সবচেয়ে ভালো নয়। সরল, পূর্বানুমেয় আর সবসময় শেষ হওয়া একটি ভিত, তার ওপর চেনা ভুলের জন্য নির্দিষ্ট সংশোধন: এটিই প্রকৌশলের ভারসাম্য।

প্র ০৩একটি batch compiler-এর parser আর একটি editor-এর parser-এর চাহিদা কোথায় আলাদা?

Batch compiler-এর কাছে ভাঙা program একটি ব্যতিক্রম: ভুল জানানো, তারপর থামা। তার output হলো বার্তার তালিকা, আর ভাঙা অংশের AST কারও দরকার নেই। Haat-এর reference ঠিক এটি: panic mode-এ বাদ পড়া statement AST-এ যায়ই না, আর error থাকলে parse_program একটি AST-ই ফেরত দেয় না।

Editor-এর কাছে ভাঙা program-ই স্বাভাবিক অবস্থা। আপনি if p >= টাইপ করেছেন, এখনো শেষ করেননি; ঠিক এই মুহূর্তে editor-কে রং দিতে হবে, function-এর তালিকা দেখাতে হবে, আর পরের ফাংশনের নাম autocomplete করতে হবে। এর জন্য দরকার একটি পুরো syntax tree, যেখানে ভাঙা অংশটিও একটি node হয়ে আছে। Tree-sitter এভাবেই নকশা করা: input যত ভাঙাই হোক, ফল একটি tree, ভেতরে ERROR node (যে token-গুলো কোথাও বসানো গেল না) আর MISSING node (যে token থাকার কথা ছিল)। C#-এর Roslyn compiler-ও “missing” token রাখে আর বাদ দেওয়া token-কে tree-এর সঙ্গে জুড়ে রাখে, যাতে tree থেকে আবার হুবহু মূল লেখা ফেরত আসে।

দ্বিতীয় পার্থক্য গতি আর incremental কাজ। Editor প্রতিটি keystroke-এ পুরো ফাইল নতুন করে parse করতে চায় না; শুধু বদলানো অংশ। তখন recovery-কে “স্থানীয়” হতে হয়: একটি function-এর ভেতরের ভুল যেন পরের function-গুলোর tree নষ্ট না করে। Haat-এর panic mode এই চিন্তার একটি ছোট রূপ: একটি পুরো { … } পার হওয়ার নিয়ম ক্ষতিকে এক block-এ আটকায়। কিন্তু অংশ ৪-এর শেষ উদাহরণ দেখিয়েছে, একটি { হারালে পুরো গঠনই সরে যায়; editor-এর parser এখানে indentation-এর মতো বাড়তি সূত্র ব্যবহার করতে পারে।

অনেক আধুনিক ভাষা তাই একই parser দুই কাজে লাগায়: compiler আর language server একই tree দেখে। এর মানে, বাজারের ভাষা বানাতে চাইলে recovery শুরুর দিন থেকেই নকশার অংশ, পরে জোড়া দেওয়ার জিনিস নয়। পর্ব ৮০-তে language server-এর কথা আবার আসবে।

মূল উপলব্ধি: Batch compiler ভাঙা input থেকে বার্তা চায়, editor চায় একটি পুরো গাছ। দ্বিতীয়টি কঠিনতর, আর তার জন্য error-কে tree-এর ভেতরের একটি node হিসেবে ভাবতে হয়, শুধু একটি exception হিসেবে নয়।

প্র ০৪“মানুষের জন্য error message” মানে কী, আর এর দাম কে দেয়?

পর্ব ৩৪-এ দেখেছেন, Elm-এর লেখক Evan Czaplicki ২০১৫ সালের দিকে “Compiler Errors for Humans” লেখায় একটি ধারণা জনপ্রিয় করেন: compiler-এর বার্তা যেন একজন সহায়ক সহকর্মীর কথা, শুধু একটি নিয়মভঙ্গের রিপোর্ট নয়। পূর্ণ বাক্য, প্রাসঙ্গিক কোডের অংশ, আর সম্ভব হলে একটি পরামর্শ। Rust-সহ কয়েকটি ভাষার বার্তার ধরন এই ধারায় প্রভাবিত হয়েছে বলে প্রায়ই বলা হয়; আজকের অনেক বার্তায় source লাইন, রঙিন দাগ, “help:” লাইন আর error code দেখা যায়, যার পেছনে বিস্তারিত ব্যাখ্যা থাকে।

এই ধারণার মূল বিষয়গুলো এই পর্বের সঙ্গে মেলে। একটি মূল দাগ, যা সমস্যার জায়গা দেখায়; সংশ্লিষ্ট জায়গা আলাদা note-এ, যেমন Clang-এর to match this '('. “কী আশা ছিল” স্পষ্ট করে বলা। আর পরামর্শ তখনই, যখন compiler-এর অনুমান যথেষ্ট নির্ভরযোগ্য; একটি ভুল পরামর্শ কোনো পরামর্শ না থাকার চেয়েও খারাপ, কারণ মানুষ তা বিশ্বাস করে মেনে নেন।

দাম কয়েক জায়গায়। প্রথমত, কোড: ভালো বার্তার জন্য parser-কে আরও তথ্য রাখতে হয় (span, খোলা বন্ধনীর অবস্থান, কাছাকাছি নাম)। দ্বিতীয়ত, test: প্রতিটি বার্তা golden file-এ, আর বার্তা বদলালে সেগুলো হালনাগাদ। তৃতীয়ত, স্থিতিশীলতা: script আর editor যদি বার্তার লেখা পড়ে, তাহলে বার্তা “সুন্দর” করাও একটি ভাঙন। এজন্য অনেক compiler মানুষের জন্য সুন্দর output-এর পাশে যন্ত্রের জন্য একটি কাঠামোবদ্ধ (যেমন JSON) output-ও দেয়।

Haat-এর reference সচেতনভাবে উল্টো দিকে: এক লাইনের ছোট ইংরেজি বার্তা, যাতে কোর্সের প্রতিটি পর্ব হুবহু মেলাতে পারে আর golden file সহজ থাকে। অংশ ৭-এর renderer দেখায় দুটি একসাথে চলে: ভেতরে সরল (line, col, বার্তা), বাইরে মানুষের জন্য সাজানো রূপ। বাংলায় বার্তা দেওয়ার চিন্তাও এখানে বসে: একটি স্থির error code বা ইংরেজি মূল বার্তা রেখে ওপরে অনুবাদ, যাতে test আর অনুসন্ধান না ভাঙে।

মূল উপলব্ধি: ভালো বার্তা একটি প্রকৌশল-সিদ্ধান্ত, শুধু লেখার ভঙ্গি নয়: তথ্য রাখা, অনুমানের নির্ভরযোগ্যতা, আর মানুষ ও যন্ত্র দুই পাঠকের জন্য আলাদা রূপ।

প্র ০৫বাংলা লেখা থাকলে caret ঠিক অক্ষরের নিচে বসানো এত কঠিন কেন?

Caret আঁকার পেছনে একটি নিঃশব্দ ধারণা আছে: source-এর প্রতিটি “কলাম” পর্দায় একটি ঘর নেয়। ASCII-তে এটি সত্য, তাই অংশ ৭-এর renderer col - 1টি space দিয়েই কাজ সারে। বাংলায় এটি ভাঙে। “দুধ” তিনটি code point: দ, ু, ধ. মাঝেরটি combining mark (Unicode category Mn), যা আগের অক্ষরের নিচে বসে, নিজে আলাদা ঘর নেয় না। ফলে Haat-এর কলাম (code point, নকশা-সিদ্ধান্ত ১) আর পর্দার ঘর এক থাকে না; let s = "দুধ"; let n = 5-এর বার্তা 1:25 code point গুনে ঠিক, কিন্তু ২৪টি space-এর পরের caret অনেক terminal-এ এক ঘর সরে যেতে পারে।

সমস্যা আরও আছে। “কি”-র ি একটি spacing mark, ঘর নেয়, কিন্তু পর্দায় ক-এর আগে আঁকা হয়। যুক্তাক্ষর “ক্ষ” তিনটি code point (ক, হসন্ত, ষ), কিন্তু চোখে একটি আকৃতি, আর কত ঘর নেবে তা font আর terminal-এর ওপর নির্ভর করে। চীনা-জাপানি অক্ষর আবার দুই ঘর চওড়া, emoji-ও প্রায়ই তাই। তাই “পর্দার কলাম” কোনো একক সংখ্যা নয়; তা নির্ভর করে কে আঁকছে তার ওপর।

বাস্তব tool কয়েকভাবে সামলায়। GCC 11 থেকে -fdiagnostics-column-unit option আছে, যা কলামকে “display” (পর্দার প্রস্থ ধরে, tab বিস্তার করে) বা “byte” হিসেবে দেখাতে দেয়। Language Server Protocol-এ client আর server আলোচনা করে কলামের একক ঠিক করে (UTF-16 ছিল পুরোনো ডিফল্ট; 3.17 থেকে UTF-8 বা UTF-32-ও); দাগ আঁকে editor নিজে, যে font আর layout জানে। আর terminal-এর renderer একটি wcwidth-ধাঁচের টেবিল দিয়ে প্রতিটি code point-এর প্রস্থ অনুমান করে, combining mark-কে শূন্য ধরে। পর্ব ৪৬-এর একটি ভাবনার প্রশ্নে কলামের একক নিয়ে এই আলোচনার শুরু, আর পর্ব ২১-এ code point আর UTF-8-এর ভিত।

Haat-এর জন্য একটি সৎ সমাধান: compiler কলাম code point-এ রাখবে, আর renderer দাগ আঁকার আগে লাইনের শুরু থেকে কলাম পর্যন্ত অংশের পর্দা-প্রস্থ হিসাব করবে, combining mark বাদ দিয়ে। পুরো নির্ভুল হবে না, কারণ terminal-ভেদে আঁকা আলাদা, কিন্তু সাধারণ বাংলা লেখায় দাগ ঠিক জায়গার অনেক কাছে আসবে।

মূল উপলব্ধি: অবস্থান রাখা (কোন code point) আর অবস্থান আঁকা (পর্দার কোন ঘর) দুটি আলাদা সমস্যা। প্রথমটি compiler-এর চুক্তি, দ্বিতীয়টি দেখানোর tool-এর দায়িত্ব; দুটিকে মিশিয়ে ফেললেই বাংলা লেখার নিচে দাগ ভুল জায়গায় পড়ে।

অনুশীলন

প্রতিটির উত্তর লেখকের ল্যাবে চালিয়ে মেলানো। নিজে আগে করে তারপর খুলুন।

  1. বাস্তবায়ন — একটি error production: নতুনরা প্রায়ই শর্তে ==-এর বদলে = লেখেন। নিচের ফাইলে reference এখন বলে 2:10: error: expected '{' after if condition আর 3:13: error: expected '{' after while condition. পাতার parser-এ একটি error production যোগ করুন, যাতে if আর while-এর শর্তের পরে = এলে বার্তা হয় '=' assigns; use '==' to compare, অবস্থান =-এর ওপর।
    var total = 0;
    if total = 0 { print("খালি"); }
    while total = 3 { total = total + 1; }

    শর্ত পড়ার পরে, block-এর আগে একটি পরীক্ষা। পাতার কোডের ওপর একটি subclass:

    class Parser(Parser):
        def eq_check(s):
            if s.check("EQ"): s.fail("'=' assigns; use '==' to compare")
        def if_rest(s):
            s.expression(); s.eq_check(); s.block("expected '{' after if condition")
            if s.match("ELSE"): s.if_rest() if s.match("IF") else s.block("expected '{' or 'if' after 'else'")
        def statement(s):
            if s.match("WHILE"):
                s.expression(); s.eq_check(); return s.block("expected '{' after while condition")
            return super().statement()

    লেখকের ল্যাবে চালানো ফল: 2:10: error: '=' assigns; use '==' to compare আর 3:13: error: '=' assigns; use '==' to compare. অবস্থান বদলায়নি, কারণ fail তখনো = token-এর ওপর; বদলেছে শুধু বার্তা। if_rest নিজেকে ডাকে বলে else if total = 2 {-ও ধরা পড়ে (ল্যাবে একটি দ্বিতীয় ফাইলে 2:43-এ), আর ঠিক করা বাজারঘর program-এ (bazar_fixed.haat) কোনো নতুন syntax error আসে না। if total == 0 {-এ কিছুই বদলায় না, কারণ == Pratt loop-এ একটি infix operator হিসেবে আগেই খাওয়া হয়ে যায়, EQ হিসেবে কখনো বাকি থাকে না। Recovery-ও আগের মতো: Panic-এর পরে নিয়ম ৪ পুরো { … } পার করে। আরও ভালো রূপে phrase-level recovery করা যায়: =-কে == ধরে নিয়ে শর্তটি পড়া চালিয়ে যাওয়া, যাতে body-র ভুলও ধরা পড়ে। লক্ষ করুন, এটি golden file-এর আউটপুট বদলায়; spec-এ বার্তাটি লিখে তবে বদলানো উচিত।

  2. ভুল খুঁজুন: এক বন্ধু synchronize-এর প্রথম শর্ত থেকে RBRACE বাদ দিয়েছেন: “depth ০-এ শুধু statement keyword-এর আগে থামব; } এলে সেটিও ফেলে দেব।” নিচের ফাইলে reference একটি error দেয়, 2:32: error: expected ';' after return. বন্ধুর parser কী দেয়, আর কেন?
    fn delivery(total: Int) -> Int {
        if total >= 1000 { return 0 }
        return 60;
    }
    print(delivery(996));

    লেখকের ল্যাবে চালানো ফল, তিনটি বার্তা:

    2:32: error: expected ';' after return
    6:1: error: expected '}' at end of block
    6:1: error: expected '}' at end of block

    return 0-এর পরে ; নেই; error 2:32-এ, আর cursor if-এর block-এর }-এর ওপর। এই } অমিল: গভীরতা ০-এ, আর এটি বাইরের block-এর, অর্থাৎ if-এর body-র শেষ চিহ্ন। আসল নিয়মে synchronize এর আগে থামে, তাই if-এর block নিজের } পায়, আর বাকি সব স্বাভাবিক। বন্ধুর নিয়মে } ফেলে দেওয়া হয়, গভীরতা −১, আর −১ কখনো ০ নয়, তাই কোনো নিয়ম আর খাটে না: return 60;, ফাংশনের }, print(…); সব একে একে ফেলে EOF পর্যন্ত। তারপর if-এর block আর ফাংশনের block দুজনেই EOF-এ (6:1, শেষ newline-এর পরে) } খোঁজে: দুটি ভুয়া বার্তা, আর print statement চুপচাপ উধাও। শিক্ষা: অমিল } সবসময় তার মালিকের জন্য রেখে দিতে হয়।

  3. Trace — output অনুমান করুন: নিচের ফাইলে (শেষে newline আছে) reference-এর python -B haat.py check ঠিক কী লেখে? প্রতিটি লাইনের line:col হাতে গুনুন, আর প্রতিটি error-এর পরে parser কোথা থেকে আবার শুরু করে তা লিখুন।
    let a = 5
    var b = (a + 2;
    if a > 1 { print(a) }
    print(b);

    Reference-এর সত্যিকারের run:

    1:10: error: expected ';' after variable declaration
    2:15: error: expected ')' after expression
    3:20: error: expected ';' after print statement

    লাইন ১: 5 কলাম ৯-এ, তাই বাদ পড়া ; 1:10-এ (আগের token-এর পরে), যদিও ভুলটি ধরা পড়ে লাইন ২-এর var দেখে। synchronize সেই var-এর আগেই থামে (নিয়ম ১), তাই লাইন ২ একটি নতুন statement. লাইন ২: বন্ধনীর ভেতরে a + 2, তারপর )-এর বদলে ; (কলাম ১৫): দাগ সেই ;-এর ওপর, কারণ এটি বাদ পড়া ; নয়, বাদ পড়া ). synchronize ; ফেলে থামে (নিয়ম ৩)। লাইন ৩: print(a)-এর ) কলাম ১৯-এ, তারপর ; নেই: 3:20. Cursor তখন }-এ, যা অমিল, তাই তার আগে থামা (নিয়ম ২), আর if-এর block নিজের } পায়। লাইন ৪ নিখুঁত। তিনটি ভুল, তিনটি বার্তা।

  4. প্রমাণ — recovery সবসময় শেষ হয়: দেখান যে পাতার (আর reference-এর) parser যেকোনো token-তালিকায় শেষ হয়, অর্থাৎ কখনো অসীম loop-এ পড়ে না। ধরে নিন token-তালিকা সসীম, শেষে একটি EOF, আর advance EOF-এ cursor সরায় না।

    প্রমাণের রূপরেখা। n = token-এর সংখ্যা; cursor pos কখনো কমে না (কোনো কোড পেছনে যায় না), আর pos ≤ n − 1.

    1. synchronize-এর loop: প্রতিটি ঘোরায় হয় সে ফেরত যায়, নয়তো advance ডাকে, যা EOF-এর আগে pos ঠিক ১ বাড়ায়; EOF-এ loop-এর শর্তই মিথ্যা। তাই সর্বোচ্চ n বার ঘোরে।
    2. statements_until-এর loop-এর একটি ঘোরার শেষে pos অন্তত ১ বাড়ে, বা loop থামে। কারণ: statement সফল হলে সে অন্তত একটি token খেয়েছে (প্রতিটি শাখা প্রথম token-টি advance বা expect করে, নয়তো prefix-এ ব্যর্থ হয়); ব্যর্থ হলে synchronize-এর পরে pos == start হলে জোর করে এক advance. একমাত্র ব্যতিক্রম EOF, কিন্তু তখন loop-এর শর্ত (not check("EOF")) মিথ্যা।
    3. Recursion-এর প্রতিটি নতুন স্তর (block, expression, parse_type) একটি token খাওয়ার পরে খোলে ({, operator, (), শুধু expression → prefix ছাড়া, যা নিজে আর expression ডাকে না token না খেয়ে। তাই একই pos-এ সীমাহীন গভীরতা হয় না; মোট ডাকের সংখ্যা n-এর একটি গুণিতকে সীমিত।
    4. ধাপ ১–৩ মিলিয়ে: প্রতিটি loop-ঘোরা বা নতুন recursion-স্তরের জন্য pos বাড়ে, আর pos n-এর বেশি বাড়তে পারে না। তাই মোট কাজ সসীম, parser শেষ হয়। ∎

    লক্ষ করুন ধাপ ২-এর “জোর করে এক advance”: এটি না থাকলে প্রমাণ ভাঙে, আর top level-এর একা }-এ সত্যিই অসীম loop হয় (অংশ ৩)। প্রমাণ শেষ হওয়ার কথা বলে, গতির নয়: Python-এ recursion-এর সীমা আলাদা সমস্যা (অংশ ৬-এর ২০,০০০ বন্ধনী)।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমHaat-এর parser একটি syntax error পাওয়ার পর যা যা করে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. অপ্রত্যাশিত token দেখে error-এর অবস্থান ঠিক করা
  2. (line, col, বার্তা) তালিকায় রাখা আর Panic ছোড়া
  3. চলতি statement ছেড়ে statements_until-এ ফেরা
  4. synchronize: নিরাপদ token পর্যন্ত ফেলে দেওয়া
  5. পরের statement থেকে আবার parse করা
  6. শেষে সব error অবস্থান ধরে সাজিয়ে দেখানো

Haat-এর দুই লাইনের source: লাইন ১-এ let x = 1 (শেষে ; নেই), লাইন ২-এ print(x);. Reference-এর বার্তা কোন অবস্থানে?

  • 2:1, print-এর ওপর
  • 1:10, 1-এর ঠিক পরে
  • 1:9, 1-এর ওপর
  • 1:1, statement-এর শুরুতে

Haat-এর reference-এর panic mode-এ (একই বন্ধনী-গভীরতা ধরে) নিচের কোনটি থামার জায়গা নয়?

  • গভীরতা ০-এ let-এর আগে
  • গভীরতা ০-এ ;-এর পরে
  • একটি { … }-এর ভেতরের ;-এর পরে
  • গভীরতা ০-এ অমিল }-এর আগে

Haat source: লাইন ১-এ let a = (1 + 2;, লাইন ২-এ let b = 3 (শেষে ; নেই, তারপর একটি নতুন লাইন)। Reference-এর check কয়টি error দেয়?

  • দুটি
  • একটি
  • তিনটি, একটি cascade-সহ
  • কোনোটিই নয়, ok

একটি panic-mode parser-এর statement-loop-এ “synchronize-এর পরে cursor না সরলে জোর করে একটি token এগোনো” লাইনটি কেন দরকার?

  • যাতে error-গুলো অবস্থান ধরে সাজানো থাকে
  • যাতে একই জায়গার দুটি বার্তা একটি হয়ে যায়
  • যাতে parser দ্রুত চলে
  • যাতে একা }-এর মতো input-এ অসীম loop না হয়

একটি ভাঙা program-এ চারটি আসল syntax error আছে। একটি parser প্রতিটি error-এর পরে ঠিক সেই অপ্রত্যাশিত token থেকেই নতুন statement শুরু করে (কিছু ফেলে না)। সাধারণত কী দেখা যায়?

  • ঠিক চারটি বার্তা, কারণ কিছুই বাদ পড়েনি
  • চারটির বেশি বার্তা, যার কয়েকটি ভুয়া (cascade)
  • শুধু প্রথম বার্তাটি
  • অবশ্যই একটি অসীম loop

Haat-এ a < b < c লিখলে parser সাধারণ “expected ';'” না বলে বলে comparison operators cannot be chained, দ্বিতীয় <-এর ওপর। এই কৌশলকে কী বলে?

  • Panic mode recovery
  • Global correction
  • Error production
  • Golden file

একটি compiler-এর প্রতিটি ভাঙা উদাহরণ-ফাইলের পাশে তার প্রত্যাশিত পুরো error output একটি ফাইলে রাখা, আর প্রতিবার হুবহু মেলানো হয় (golden file পদ্ধতি)। এই test সবচেয়ে ভালো কী ধরে?

  • বার্তা বা অবস্থানের যেকোনো অনিচ্ছাকৃত বদল
  • বার্তাটি মানুষের কাছে বোধগম্য কি না
  • কল্পনা করা হয়নি এমন নতুন ভাঙা input-এর crash
  • Parser-এর গতি কমে গেছে কি না

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. ভালো diagnostic: সঠিক line:col, কী আশা ছিল, আর একটি মূল দাগ; সংশ্লিষ্ট জায়গা আলাদা note-এ।
  2. বাদ পড়া ; দেখানো হয় আগের token-এর ঠিক পরে; অন্য syntax error অপ্রত্যাশিত token-এ (নকশা-সিদ্ধান্ত ২৪)।
  3. Panic mode: Panic ছুড়ে statement ছাড়া, তারপর গভীরতা গুনে ;-এর পরে, পুরো { … }-এর পরে, keyword বা অমিল }-এর আগে থামা; অগ্রগতি না হলে জোর করে এক ধাপ এগোনো।
  4. Recovery-র মাপকাঠি cascade: একই ভাঙা program-এ panic ৪, তাৎক্ষণিক শুরু ৭, সব-বাদ ২টি বার্তা দিয়েছে; শুধু প্রথমটিতে সব বার্তা আসল।
  5. বার্তা একটি চুক্তি: golden file বদল ধরে, mutation fuzzing crash আর ভুল অবস্থান ধরে, differential test বার্তার সঠিকতা যাচাই করে।

পরের পর্বে: Syntax এখন নিখুঁত হলে কী? undefined variable 'delivery' আসে পরের ধাপ থেকে। মডিউল ৯ শুরু হবে symbol table দিয়ে: scope-এর stack, নাম খোঁজা, আর reference-এর resolver.py কীভাবে প্রতিটি নামকে তার ঘোষণার সঙ্গে জোড়ে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান