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

অন্য semantic check — definite assignment, unreachable code আর exhaustiveness

Other Semantic Checks — Definite Assignment, Unreachable Code and Exhaustiveness

Taught in Bangla, this lesson covers static checks that run after type checking. It explains why such checks must trade soundness against completeness, then writes passes in in-page Python (Pyodide) for unreachable code after return, unused variables and definite assignment as a set carried forward with intersection at joins, explores pattern exhaustiveness and redundant arms in JavaScript, compares error and warning choices in real Clang and javac, and validates the passes on random programs.

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

  • Type checking-এর পরে compiler আর কী কী static check করে, আর কোনটি error, কোনটি warning হওয়া উচিত
  • Haat AST-এর ওপর unreachable code আর unused variable খোঁজার pass নিজে লেখা
  • Java আর C#-এর definite assignment, Haat-এর নিয়মের (decision 16, 18, 26) সঙ্গে তুলনা, আর একটি set-ভিত্তিক বিশ্লেষণ
  • Nested pattern-এর exhaustiveness আর অপ্রয়োজনীয় arm খোঁজার usefulness algorithm
  • Sound আর complete-এর আপস, আর একটি pass-কে random program ও সত্যিকারের Clang/javac দিয়ে যাচাই করা

১ · Type-এর বাইরে — compiler আর কী কী দেখে

পর্ব ৫১-এ (Symbol table আর name resolution) Haat-এর resolver প্রতিটি নামকে তার ঘোষণার সঙ্গে জুড়েছে। পর্ব ৫২-এ (Type checker বাস্তবায়ন) type checker পর্ব ৩৪-এর (Typing rule আর type judgment) নিয়ম কোডে নামিয়েছে। দুটি পার হওয়ার পরেও একটি program-এ এমন ভুল থাকতে পারে যার সঙ্গে নাম বা type-এর কোনো সম্পর্ক নেই। Semantic analysis-এর এই শেষ অংশই এই পর্বের বিষয়।

বাজারে যাওয়ার আগে মা ফর্দটি একবার দেখে নেন। প্রতিটি জিনিসের নাম ঠিক আছে, পরিমাণের ঘরে সংখ্যাই লেখা: অর্থাৎ নাম আর type ঠিক। তবু তিনি বলেন, “তেল দুবার লিখেছিস, আর ‘টাকা শেষ হলে বাড়ি ফিরবি’ লেখার পরে আরও তিনটি জিনিস লিখেছিস, ওগুলো কেনাই হবে না।” আবার, “মাছের দাম লিখিসনি, অথচ যোগফলে মাছ ধরেছিস।” ফর্দ না খুলেই, বাজারে না গিয়েই এই ভুলগুলো ধরা যায়। Compiler-এর অন্য semantic check ঠিক এই কাজ করে।

এই পর্বের প্রতিটি check একটি static analysis: program না চালিয়ে, শুধু কোড পড়ে প্রশ্নের উত্তর খোঁজা। চারটি প্রধান প্রশ্ন:

Checkপ্রশ্নJava 21Clang 22 (C)Haat reference
Unreachable codeএই statement-এ কি কখনো পৌঁছানো যায়?errorwarning, -Wunreachable-code চাইলেকিছু বলে না
Unused variableঘোষিত নামটি কি কোথাও পড়া হয়?কিছু বলে না (IDE বলে)warning, -Wall-একিছু বলে না
Definite assignmentপড়ার আগে প্রতিটি পথে মান বসেছে কি?errorwarning, -Wall-এপ্রশ্নই ওঠে না: সব let/var-এ initializer বাধ্যতামূলক
Exhaustivenessmatch বা switch কি সব সম্ভাব্য মান ধরে?switch expression-এ errorenum-এর switch-এ warning, ডিফল্টে চালুv1-এ match নেই

পঞ্চম একটি ছোট দল হলো constant-expression check: যে হিসাব compile-এর সময়েই জানা, তাতে ভুল থাকলে আগেই বলা, যেমন শূন্য দিয়ে ভাগ (অংশ ৬)। Java আর Clang-এর ঘরগুলো আন্দাজে নয়, অংশ ৭-এর সত্যিকারের run থেকে নেওয়া।

Haat reference শুধু error দেয়, কখনো warning দেয় না। এই পর্বে Haat-এ warning যোগ করা হবে Haat-এর বর্ধিত রূপ হিসেবে, reference-এর error-এর আকার মেনে: <line>:<col>: warning: <message>. Warning program চালানো আটকায় না; python -B haat.py check তখনো ok বলে। Definite assignment-এর জন্য আরেকটি বর্ধিত রূপ লাগবে: initializer ছাড়া var fee: Int;. প্রতিটি warning বা error একটি diagnostic, তাই তার অবস্থান (line:col) ঠিক হওয়া জরুরি।

সব pass একটি সহায়ক module ব্যবহার করে: haat_front.py (lexer, AST আর parser, পর্ব ৫১-এর পাতার হুবহু একই module), আর তার ওপর haat_resolve.py, যাতে আছে পর্ব ৫১-এর তিন ব্লকের resolver আর একটি ছোট সংযোজন: প্রতিটি নাম-ব্যবহার (node, Binding) জোড়া হিসেবে refs তালিকায় রাখা। দ্বিতীয়টি এখানে খোলা যায়:

সহায়ক module haat_resolve.py দেখুন (ব্লক ২ আর ৩ এটি import করে)
# haat_resolve.py — পর্ব ৫১-এর resolver (reference-এর resolver.py-র সংক্ষিপ্ত রূপ), হুবহু;
# শেষে একটি ছোট সংযোজন: প্রতিটি নাম-ব্যবহার (node, Binding) জোড়া হিসেবে refs-এ রাখা।
from haat_front import *
@dataclass(eq=False)
class Binding:                    # resolver.py: one symbol-table entry
    name: str; kind: str          # kind: "let", "var", "param" or "fn"
    depth: int; slot: int; is_global: bool
    owner: object; line: int; col: int    # owner: FnDecl/Lambda, None = main
    captured: bool = False        # used by an inner function -> needs a cell
@dataclass
class Scope:                      # one block: names so far + names still to come
    names: dict = field(default_factory=dict); pending: set = field(default_factory=set)
def declared_names(stmts): return {s.name for s in stmts if isinstance(s, (Let, FnDecl))}
class Resolver:
    def __init__(self):
        self.scopes, self.errors, self.uses, self.decls = [], [], {}, {}
        self.nslots, self.nglobals, self.owner, self.depth = {None: 0}, 0, None, 0
    def error(self, node, msg): self.errors.append((node.line, node.col, msg))
    def declare(self, node, name, kind):
        scope, is_global = self.scopes[-1], len(self.scopes) == 1
        if name in scope.names: self.error(node, f"'{name}' is already declared in this scope")
        key = None if self.owner is None else id(self.owner)
        if is_global: slot, self.nglobals = self.nglobals, self.nglobals + 1
        else: slot = self.nslots[key]; self.nslots[key] += 1
        b = Binding(name, kind, self.depth, slot, is_global, self.owner, node.line, node.col)
        scope.names[name] = b; scope.pending.discard(name); self.decls[id(node)] = b; return b
    def lookup(self, node, name):
        for scope in reversed(self.scopes):        # innermost scope first
            if name in scope.names:
                b = scope.names[name]
                if not b.is_global and b.owner is not self.owner: b.captured = True
                self.uses[id(node)] = b; return b
            if name in scope.pending: return self.error(node, f"'{name}' is used before its declaration")
        return self.error(node, f"undefined variable '{name}'")

class Resolver(Resolver):         # resolver.py: the walk over the AST
    def program(self, prog):
        self.scopes.append(Scope(pending=declared_names(prog.stmts)))
        for f in [s for s in prog.stmts if isinstance(s, FnDecl)]: self.declare(f, f.name, "fn")  # pass 1: hoist
        for s in prog.stmts:                       # pass 2: everything, in order
            self.function(s) if isinstance(s, FnDecl) else self.stmt(s)
        return [f"{l}:{c}: error: {m}" for l, c, m in sorted(self.errors, key=lambda e: e[:2])]
    def function(self, f):                         # FnDecl or Lambda: a new slot owner
        saved, self.owner, self.depth = (self.owner, self.depth), f, self.depth + 1; self.nslots[id(f)] = 0
        self.scopes.append(Scope(pending=declared_names(f.body.stmts)))
        for p in f.params: self.declare(p, p.name, "param")
        for s in f.body.stmts: self.stmt(s)        # params + body: one scope (decision 14)
        self.scopes.pop(); self.owner, self.depth = saved
    def stmt(self, s):
        if isinstance(s, Let): self.expr(s.init); self.declare(s, s.name, "var" if s.mutable else "let")
        elif isinstance(s, FnDecl): self.declare(s, s.name, "fn"); self.function(s)
        elif isinstance(s, Assign): self.expr(s.value); self.lookup(s, s.name)
        elif isinstance(s, If):
            self.expr(s.cond); self.stmt(s.then)
            if s.else_ is not None: self.stmt(s.else_)  # a Block, or the If of `else if`
        elif isinstance(s, While): self.expr(s.cond); self.stmt(s.body)
        elif isinstance(s, Return) and s.value is not None: self.expr(s.value)
        elif isinstance(s, (Print, ExprStmt)): self.expr(s.value if isinstance(s, Print) else s.expr)
        elif isinstance(s, Block):                 # every { } is a scope
            self.scopes.append(Scope(pending=declared_names(s.stmts)))
            for x in s.stmts: self.stmt(x)
            self.scopes.pop()
    def expr(self, e):
        if isinstance(e, Var): self.lookup(e, e.name)
        elif isinstance(e, Lambda): self.function(e)
        elif isinstance(e, Unary): self.expr(e.operand)
        elif isinstance(e, Binary): self.expr(e.left); self.expr(e.right)
        elif isinstance(e, Call): [self.expr(x) for x in [e.callee, *e.args]]

class Resolver(Resolver):         # resolver.py: the rules on top of the walk
    def stmt(self, s):
        if isinstance(s, Return) and self.owner is None:      # decision 20
            self.error(s, "'return' outside of a function")
        super().stmt(s)
        b = self.uses.get(id(s)) if isinstance(s, Assign) else None
        if b and b.kind != "var":                             # decision 19: only var
            what = {"let": f"'{s.name}': it is declared with 'let'",
                    "param": f"parameter '{s.name}'", "fn": f"function '{s.name}'"}[b.kind]
            self.error(s, f"cannot assign to {what}")

def check_names(src):             # like `haat.py check`, names only
    r = Resolver(); errors = r.program(parse(src))
    return r, errors or ["ok"]


class Resolver(Resolver):         # পর্ব ৫৪-এর সংযোজন: প্রতিটি ব্যবহার জোড়ায় রাখা
    def __init__(self): super().__init__(); self.refs = []
    def lookup(self, node, name):
        b = super().lookup(node, name)
        if b: self.refs.append((node, b))     # node: Var (পড়া) বা Assign (লেখা)
        return b

২ · Sound না complete — প্রতিটি check-এর আপস

“এই statement কি কখনো চলবে?” প্রশ্নটি সাধারণভাবে Rice-এর theorem-এর আওতায় পড়ে: program-এর আচরণ নিয়ে যেকোনো non-trivial প্রশ্ন undecidable (গণনার তত্ত্ব কোর্সের পর্ব ৫৩). উদাহরণ: if goldbach_holds(n) { print("x"); }-এর print চলবে কি না, তা জানতে একটি খোলা গাণিতিক প্রশ্নের উত্তর লাগে। তাই প্রতিটি বাস্তব check একটি সহজ, সবসময় থামে এমন নিয়ম ব্যবহার করে, আর মেনে নেয় যে কিছু ক্ষেত্রে উত্তর ভুল হবে। প্রশ্ন একটিই: কোন দিকে ভুল হবে?

সংজ্ঞা ৫৪.১ — sound আর complete

একটি check C কিছু program-কে “খারাপ” বলে আটকায়। C sound, যদি সত্যিকারের প্রতিটি খারাপ program আটকায় (কোনো false negative নেই)। C complete, যদি কোনো ভালো program আটকায় না (কোনো false positive নেই)। Rice-এর theorem অনুযায়ী আচরণ-সংক্রান্ত non-trivial প্রশ্নে একটি সবসময় থামে এমন check একসঙ্গে দুটিই হতে পারে না। যে check নিরাপদ দিকটি বেছে নেয়, তাকে বলে conservative.

“খারাপ” কী, তা প্রতিটি check-এর জন্য আলাদা, তাই নিরাপদ দিকও আলাদা:

Checkকী দাবি করেনিরাপদ দিকদাম
Definite assignment (error)“এখানে পড়া নিরাপদ”sound: সন্দেহ হলেই আটকানোকিছু ঠিক program আটকায়; প্রোগ্রামারকে একটি বাড়তি assignment লিখতে হয়
Missing return (Haat decision 21)“function-এর শেষে পড়ে যাওয়া অসম্ভব”soundwhile true-এর ভেতরে return থাকলেও error (অংশ ৩)
Unreachable code (warning)“এই statement কখনো চলে না”দাবিটি সত্য হতে হবে: সন্দেহ হলে চুপঅনেক মৃত কোড ধরা পড়ে না
Unused variable (warning)“নামটি কখনো পড়া হয় না”লেখায় একবারও পড়া থাকলে চুপtries = tries + 1-এর মতো অর্থহীন পড়া ধরা পড়ে না (অংশ ৪)
Exhaustiveness (error)“কোনো মান match থেকে বেরিয়ে যায় না”sound: guard থাকলে guard-কে মিথ্যা ধরে নেওয়াগণিতে সম্পূর্ণ match-ও কখনো আটকায় (পর্ব ২৪-এর guard-এর ফাঁদ)

একটি সূক্ষ্ম পার্থক্য লক্ষ করুন। Error-এর নিয়ম ভাষার specification-এ লেখা থাকলে সেটি সরল আর পূর্বানুমেয় হওয়া জরুরি, কারণ প্রতিটি compiler-কে একই program একইভাবে গ্রহণ বা বর্জন করতে হবে। Java-র specification (JLS) তাই definite assignment আর reachability-র নিয়ম পুরোপুরি কোডের গঠন দেখে লিখেছে, চলার সময়ের মান দেখে নয়। Warning-এর এমন বাধ্যবাধকতা নেই; তাই Clang-এর warning অনেক বেশি চতুর বিশ্লেষণ করতে পারে, আর compiler-ভেদে আলাদাও হতে পারে। কেন কিছু বিশ্লেষণ মৌলিকভাবেই আনুমানিক, তার পুরো তত্ত্ব গণনার তত্ত্ব কোর্সের পর্ব ৭৮-এ।

৩ · Unreachable code — return-এর পরের লাইন

Haat-এর reference-এর একটি ফাংশন আগেই প্রায় এই কাজ করে: typechecker.py-এর always_returns(stmts), যা missing return-এর নিয়ম (decision 21, পর্ব ৩৪-এ গণিতে আর পর্ব ৫২-এ কোডে) বাস্তবায়ন করে। তার প্রশ্ন “এই তালিকা কি প্রতিটি পথে return করে?” আমাদের প্রশ্ন প্রায় উল্টো: “এই statement শেষ করে কি পরের statement-এ যাওয়া যায়?” Java-র specification এই ধারণার নাম দিয়েছে can complete normally. নিয়মগুলো:

  • return কখনো সাধারণভাবে শেষ হয় না। let, var, assignment, print, expression statement সবসময় শেষ হয়।
  • একটি statement তালিকা শেষ হয় যদি তার শেষ statement শেষ হয়; আর কোনো statement শেষ না হলে তার পরের statement unreachable.
  • else-সহ if শেষ হয় যদি অন্তত একটি শাখা শেষ হয়; else ছাড়া if সবসময় শেষ হয় (শর্ত মিথ্যা হলে সরাসরি পরে যাওয়া যায়)।
  • while শেষ হয়, যদি না শর্তটি literal true (Haat-এ break নেই, তাই while true থেকে বেরোনোর একমাত্র পথ return). শর্ত literal false হলে body-র প্রথম statement unreachable.

শেষ নিয়মটি একটি constant expression-এর ওপর নির্ভর করে। Java এটিকে আরও বিস্তৃত করেছে: 1 > 2-এর মতো compile-এর সময় হিসাব করা যায় এমন প্রতিটি শর্ত সেখানে constant. পাতার কোড শুধু literal true/false দেখে, সরল রাখার জন্য। প্রতিটি মৃত তালিকায় শুধু প্রথম মৃত statement-এ একটি warning, কারণ পরের সবগুলো একই কারণে মৃত; Java আর Clang-ও তা-ই করে।

নিচের ব্লকের ইনপুট coupon.haat, বাজারঘরের কুপনের হিসাব, যাতে ইচ্ছা করে চার রকম মৃত কোড রাখা। Reference এই ফাইলে check চালালে ok বলে আর run-এ ছাপে 150 আর 1 (সত্যিকারের run):

// বাজারঘর: কুপনের ছাড়
fn discount(total: Int, code: Str) -> Int {
    if code == "EID10" {
        return total / 10;
        print("EID10 applied");
    } else {
        return 0;
    }
    return -1;
}
fn wait_stock(n: Int) -> Int {
    var k = n;
    while true {
        if k > 0 { return k; }
        k = k + 1;
    }
    print("never");
    return 0;
}
while false { print("debug"); }
if false { print("trace"); }
print(discount(1500, "EID10"));
print(wait_stock(-2));
from haat_front import *          # parse আর AST: পর্ব ৫১-এর একই সহায়ক module
warnings = []
def warn(node, msg): warnings.append((node.line, node.col, msg))
def exprs(s):                     # statement-এর সরাসরি expression-গুলো
    return [getattr(s, f) for f in ("init", "value", "cond", "expr") if getattr(s, f, None) is not None]
def lambdas(e):                   # expression-এর ভেতরের সব fn(...) { ... }
    if isinstance(e, Lambda): yield e
    for f in ("operand", "left", "right", "callee"):
        if hasattr(e, f): yield from lambdas(getattr(e, f))
    for a in getattr(e, "args", []): yield from lambdas(a)
def is_const(e, v): return isinstance(e, Bool) and e.value == v
def completes(s):                 # s শেষ করে পরের statement-এ পৌঁছানো যায় কি?
    for f in (f for e in exprs(s) for f in lambdas(e)): reach(f.body.stmts)
    if isinstance(s, Return): return False
    if isinstance(s, FnDecl): reach(s.body.stmts); return True
    if isinstance(s, Block): return reach(s.stmts)
    if isinstance(s, If):
        t = reach(s.then.stmts)
        return True if s.else_ is None else completes(s.else_) or t
    if isinstance(s, While):
        if is_const(s.cond, False):           # `while false`: body কখনো চলে না
            if s.body.stmts: warn(s.body.stmts[0], "unreachable statement")
        else: reach(s.body.stmts)
        return not is_const(s.cond, True)     # `while true`-এর পরে যাওয়ার পথ নেই
    return True                               # let, var, assign, print, expr
def reach(stmts):                 # একটি তালিকা; প্রথম মৃত statement-এ একটি warning
    live = True
    for s in stmts:
        if not live: warn(s, "unreachable statement"); return False
        live = completes(s)
    return live
reach(parse(open("coupon.haat", encoding="utf-8").read()).stmts)
for l, c, m in sorted(warnings, key=lambda w: w[:2]): print(f"{l}:{c}: warning: {m}")

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

5:9: warning: unreachable statement
9:5: warning: unreachable statement
17:5: warning: unreachable statement
20:15: warning: unreachable statement

চারটি warning, চার কারণে। 5:9: then-শাখায় return-এর ঠিক পরের print. 9:5: if-এর দুই শাখাই return করে, তাই if নিজে শেষ হয় না, আর return -1;-এ কখনো পৌঁছানো যায় না। 17:5: while true থেকে বেরোনোর পথ শুধু ভেতরের return, তাই লুপের পরের print("never") মৃত; তার পরের return 0;-এ আলাদা warning নেই। 20:15: while false-এর body. আর if false? কোনো warning নেই, ইচ্ছা করেই: Java-র নিয়মেও if (false) বৈধ, কারণ সেটি debug কোড চালু-বন্ধ করার প্রচলিত উপায় (অংশ ৭-এ javac-এর সত্যিকারের আচরণ)। লক্ষ করুন, lambdas ফাংশনটি expression-এর ভেতরের নামহীন function খুঁজে তাদের body-ও পরীক্ষা করে; এই ফাইলে তেমন কিছু নেই।

নিচের stepper-এ একই pass ধাপে ধাপে। প্রতিটি ধাপের live আর warning ল্যাবে ব্লকটিকে একটি logging সংস্করণে চালিয়ে মেলানো।

2fn discount(total: Int, code: Str) -> Int {3    if code == "EID10" {4        return total / 10;5        print("EID10 applied");6    } else {7        return 0;8    }9    return -1;10}11fn wait_stock(n: Int) -> Int {12    var k = n;13    while true {14        if k > 0 { return k; }15        k = k + 1;16    }17    print("never");18    return 0;19}20while false { print("debug"); }21if false { print("trace"); }
Pass-এর ভেতরে
তালিকা
live
এইমাত্র
  1. শুরু. reach top-level তালিকা হাঁটে। প্রথম statement একটি FnDecl: তার body-র তালিকা আলাদা করে পরীক্ষা হয়, আর top level-এর জন্য function ঘোষণা সবসময় “শেষ হয়”।
  2. Then-শাখা. if-এর then-তালিকার প্রথম statement return total / 10;. এটি কখনো সাধারণভাবে শেষ হয় না, তাই live এখন false.
  3. প্রথম warning. তালিকায় আরও একটি statement আছে, অথচ live false: 5:9-এর print unreachable. Warning দিয়ে তালিকার কাজ শেষ; then-শাখা “শেষ হয় না”।
  4. Else-শাখা. return 0;, তাই else-ও শেষ হয় না। if শেষ হয় যদি যেকোনো শাখা শেষ হয়: false or false = false.
  5. দ্বিতীয় warning. Body-র তালিকায় if-এর পরে return -1;, কিন্তু live false: 9:5 মৃত। Reference-এর always_returns এখানে true বলে; দুটি উত্তর একই কথার দুই দিক।
  6. while true. wait_stock-এর body: var k শেষ হয়। লুপের শর্ত literal true, তাই body পরীক্ষা হয় (সেখানে কোনো মৃত কোড নেই), কিন্তু লুপ নিজে কখনো সাধারণভাবে শেষ হয় না।
  7. তৃতীয় warning. 17:5-এর print("never") মৃত। তার পরের return 0;-ও মৃত, কিন্তু একই কারণে, তাই আলাদা warning নয়। মজার কথা: reference এই return 0; না পেলে missing return error দিত (অংশের শেষে)।
  8. Top level-এর বাকি. while false-এর body-র প্রথম statement (20:15) মৃত। if false-এ ইচ্ছা করে কোনো warning নেই, Java-র নিয়মের মতো। মোট চারটি warning, আর check তবু ok.

এবার একটি অসংগতি। wait_stock থেকে শেষের অপ্রয়োজনীয় দুটি লাইন মুছে দিলে reference কী বলে (সত্যিকারের run)?

~/haat $ python -B haat.py check wait.haat
1:4: error: missing return: not every path of function 'wait_stock' returns Int

Decision 21 ইচ্ছা করে বলে “while কখনো গোনা হয় না, while true-ও নয়”। ফলে reference এমন function আটকায় যা কখনো শেষে পড়ে যেতে পারে না: sound কিন্তু complete নয়। আমাদের reachability pass ঠিক উল্টো কথা বলে: while true-এর পরের কোড মৃত। Java দুটিকে একই নিয়মে বেঁধেছে: “method-এর body সাধারণভাবে শেষ হতে পারলে missing return”, তাই Java-তে while (true)-ওয়ালা একই method বৈধ (অংশ ৭)। Haat চাইলে decision 21-কে এই pass দিয়ে বদলাতে পারত; v1 সরলতা বেছে নিয়েছে।

৪ · Unused variable — error নয়, warning

ঘোষিত কিন্তু কখনো না পড়া variable সাধারণত দুটির একটি বোঝায়: পুরোনো কোডের অবশেষ, অথবা একটি bug, যেমন হিসাব করা হলো কিন্তু ভুল নামের variable ফেরত দেওয়া হলো। Resolver ইতিমধ্যে প্রতিটি ব্যবহারকে binding-এর সঙ্গে জুড়েছে, তাই এই check প্রায় বিনামূল্যে: refs-এ প্রতিটি binding কতবার পড়া (Var) আর কতবার লেখা (Assign) হয়েছে গুনে ফেলা। পড়া শূন্য হলে warning; লেখা থাকলে বার্তা আলাদা, Clang-এর set but not used-এর মতো।

কয়েকটি নীতি, বাস্তব compiler থেকে নেওয়া। Parameter-এর জন্য warning ডিফল্টে বন্ধ: function-এর আকার প্রায়ই অন্য কারও চুক্তি মেনে চলে (Clang-এ -Wunused-parameter আসে -Wextra-এ)। _ দিয়ে শুরু নামে warning নেই: Rust-এর প্রচলিত রীতি, “জেনেশুনে ব্যবহার করছি না”। Top-level function-এ warning নেই, কারণ সেটি program-এর বাইরের দিকে খোলা মুখ। আর নামের error থাকলে warning-ই নয়: reference-এর মতো (decision 2) আগের ধাপ ব্যর্থ হলে পরের ধাপ চলে না।

from haat_resolve import *        # parse + পর্ব ৫১-এর Resolver; r.refs = (node, Binding)
def unused(src, params=False):
    r = Resolver(); errors = r.program(parse(src))
    if errors: return errors      # নামের error থাকলে warning-এর হিসাব অর্থহীন
    reads, writes = {}, {}
    for node, b in r.refs:        # Var = পড়া, Assign = লেখা
        d = reads if isinstance(node, Var) else writes
        d[id(b)] = d.get(id(b), 0) + 1
    found = []
    for b in r.decls.values():
        if reads.get(id(b)) or b.name.startswith("_"): continue
        if b.kind == "param" and not params: continue      # Clang-এর মতো, চাইলে চালু
        if b.kind == "fn" and b.is_global: continue        # top-level fn: program-এর মুখ
        what = {"param": "parameter", "fn": "function"}.get(b.kind, "variable")
        msg = (f"variable '{b.name}' is assigned but never read" if writes.get(id(b))
               else f"unused {what} '{b.name}'")
        found.append((b.line, b.col, msg))
    return [f"{l}:{c}: warning: {m}" for l, c, m in sorted(found, key=lambda w: w[:2])] or ["no warnings"]
src = open("cart.haat", encoding="utf-8").read()
print(*unused(src), sep="\n"); print("-- params=True"); print(*unused(src, params=True), sep="\n")
print("-- bazar.haat:", *unused(open("bazar.haat", encoding="utf-8").read()))
print("-- error:", *unused("let a = 1;\nprint(b);"))

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

3:9: warning: unused variable 'vat'
10:9: warning: variable 'note' is assigned but never read
-- params=True
2:38: warning: unused parameter 'coupon'
3:9: warning: unused variable 'vat'
10:9: warning: variable 'note' is assigned but never read
-- bazar.haat: no warnings
-- error: 2:7: error: undefined variable 'b'

cart.haat-এ vat ঘোষিত কিন্তু কোথাও নেই; note-এ একবার লেখা হয়েছে, কখনো পড়া হয়নি। Parameter-এর warning চালু করলে coupon-ও আসে, অবস্থান তার নামের ঘর (2:38). bazar.haat পরিষ্কার। শেষ লাইন দেখায় নামের error থাকলে শুধু reference-এর হুবহু error (2:7: error: undefined variable 'b'), কোনো warning নয়। কিন্তু tries-এর কী হলো? সেটি পরের stepper-এ।

2fn cart_total(items: Int, unit: Int, coupon: Str) -> Int {3    let vat = 15;4    var count = 0;5    var subtotal = 0;6    while count < items {7        subtotal = subtotal + unit;8        count = count + 1;9    }10    var note = "new";11    note = "checked";12    var tries = 0;13    tries = tries + 1;14    return subtotal;15}16print(cart_total(3, 120, "NONE"));
পড়া (r) আর লেখা (w)
vat
count
subtotal
note
tries
coupon
  1. Resolver আগে. পর্ব ৫১-এর resolver চলে, কোনো error নেই। ৯টি binding: cart_total (global fn), তিনটি param, আর vat, count, subtotal, note, tries. সব গণনা শূন্য।
  2. লুপের শর্ত. 6:11-এ count আর 6:19-এ items পড়া হলো। এগুলো refs-এ Var হিসেবে আছে, তাই “পড়া”।
  3. লুপের body. 7:20-এ subtotal আর 7:31-এ unit পড়া, 7:9-এ subtotal লেখা (Assign); 8:17-এ count পড়া, 8:9-এ লেখা।
  4. দুটি সন্দেহজনক লাইন. 11:5-এ note লেখা, পড়া নেই। 13:5-এ tries লেখা, আর 13:13-এ ডান পাশে tries পড়া: গণনায় এটি একটি পড়া।
  5. বাকি ব্যবহার. 14:12-এ subtotal পড়া (ফেরত মান), 16:7-এ cart_total. মোট ১২টি ব্যবহার refs-এ।
  6. হিসাব. vat: পড়া ০, লেখা ০ → unused variable. note: পড়া ০, লেখা ১ → assigned but never read. tries: পড়া ১, তাই চুপ, যদিও তার মান কোনো কাজে লাগে না। এটিই এই সরল গণনার সীমা; Clang-ও tries = tries + 1-এ চুপ থাকে, কিন্তু left -= 1 ধরে (অংশ ৭)। অনুশীলন ১-এ এটি সারাবেন।

একটি প্রশ্ন থেকে যায়: unused variable কেন error নয়? বেশিরভাগ ভাষা মনে করে কোড লেখার মাঝপথে একটি variable সাময়িকভাবে অব্যবহৃত থাকা স্বাভাবিক, আর তার জন্য build আটকানো বিরক্তিকর। Go ভাষা উল্টো সিদ্ধান্ত নিয়েছে: সেখানে ব্যবহার না হওয়া local variable আর import সরাসরি compile error. আর C++17 এনেছে [[maybe_unused]], Rust দেয় #[allow(unused)]: warning ঠিক জায়গায় চুপ করানোর ঘোষিত উপায়। ভাবনার প্রশ্ন ৫-এ এর আলোচনা।

৫ · Definite assignment — পড়ার আগে মান বসেছে তো?

C17-এ int fee; লিখে মান না বসিয়ে পড়লে ফল অনির্ধারিত (indeterminate value; কিছু ক্ষেত্রে undefined behavior). Java ভাষা ১৯৯৬ সালের প্রথম specification থেকেই এর একটি static সমাধান দিয়েছে: local variable পড়ার আগে compiler-কে প্রমাণ করতে হবে যে প্রতিটি সম্ভাব্য পথে তাতে মান বসেছে; না পারলে compile error. JLS-এর পুরো একটি অধ্যায় (chapter 16, “Definite Assignment”) এই নিয়মগুলো লেখে। C# একই ধারণা নিয়েছে (error CS0165, “Use of unassigned local variable”), আর Rust-এও মান না বসা variable পড়া compile error.

Haat এই প্রশ্ন অন্যভাবে সামলায়। v1-এ প্রতিটি let আর var-এ initializer বাধ্যতামূলক, তাই local variable-এর ক্ষেত্রে প্রশ্নই ওঠে না। বাকি তিনটি ফাঁক তিন নিয়মে বন্ধ:

পরিস্থিতিHaatJava 21JavaScript (let)
ঘোষণার আগে একই block-এ ব্যবহারstatic error, decision 16error: cannot find symbol (বাইরে একই নামের field থাকলে অবশ্য সেটিই পায়)চলার সময় ReferenceError (TDZ)
নিজের initializer-এ নিজেকে পড়া: let a = a + 1;static error, decision 16error: might not have been initializedচলার সময় ReferenceError
initializer ছাড়া ঘোষণা, কিছু পথে মান বসে নাv1-এ লেখাই যায় নাstatic error (chapter 16)প্রশ্ন নেই: মান undefined
Hoisted function চলে variable-এর let-এর আগেruntime error: 'k' is not initialized yet (decision 18, 26)প্রযোজ্য নয়চলার সময় ReferenceError

শেষ সারিটি আসল শিক্ষা। Top-level function hoisted, তাই কোন ডাক কখন চলবে তা জানতে পুরো program-এর call graph আর চলার ক্রম লাগে; সাধারণভাবে সেটি undecidable. Haat এখানে static নিয়ম ছেড়ে runtime পরীক্ষা বেছে নিয়েছে, আর এটি একটি সচেতন আপস (পর্ব ৫১-এর শেষ অংশ)।

এবার Haat-এর বর্ধিত রূপ: var fee: Int;, initializer ছাড়া। তখন Java-র মতো একটি check লাগবে। বিশ্লেষণটি একটি dataflow analysis-এর হালকা রূপ: program-এর প্রতিটি বিন্দুতে একটি set A, “এখানে পৌঁছানোর প্রতিটি পথে মান পেয়েছে এমন variable”. নিয়মগুলো:

সংজ্ঞা ৫৪.২ — definite assignment-এর হিসাব

Ain থেকে Aout: x = e; দেয় A ∪ {x}; return দেয় ⊤ (“এখানে পৌঁছানো যায় না”, তাই যেকোনো দাবি সত্য); if-এর ফল দুই শাখার Aout-এর ছেদ, thenout ⊓ elseout, যেখানে else না থাকলে elseout = Ain, আর ⊤ ⊓ S = S; while c-এর ফল Ain, কারণ body শূন্যবারও চলতে পারে (শুধু literal true হলে ⊤)। কোনো tracked variable x পড়া হলে x ∉ A হলে error: variable 'x' might not have been assigned.

এখানে ⊓ (meet) হলো set-এর ছেদ, কারণ প্রশ্নটি “সব পথে” (একে বলে must-analysis). Set-গুলো একটি lattice-এর উপাদান, আর ⊤ তার সবচেয়ে ওপরের উপাদান। Loop-এর জন্য সাধারণ dataflow analysis-কে একটি fixpoint পর্যন্ত বারবার হিসাব করতে হয়; এখানে দরকার হয় না, কারণ assignment শুধু set বাড়ায়, তাই loop-এর শুরুর A মানে Ain-ই। পূর্ণ কাঠামো, control flow graph-এর ওপর liveness আর reaching definition, আসবে পর্ব ৬৪-এ (Dataflow analysis).

ছবি ৫৪.১ — charge-এর control flow graph আর প্রতিটি পথের A

প্রতিটি তীরের পাশে সেখানে পৌঁছানোর সময়ের set A. তিনটি পথ মিলনের বিন্দুতে আসে; ছেদ খালি, তাই শেষ লাইনে fee পড়া error.

Definite assignment over the control flow graph of charge var fee: Int; zone=="dhaka" fee = 60; =="outside" fee = 120; ⊓ return total + fee; A = { } সত্য মিথ্যা {fee} {fee} সত্য মিথ্যা { } = { } fee ∉ A → error 9:20
ছবি ৫৪.১ — দুটি পথে fee মান পায়, তৃতীয় পথে (zone “dhaka” বা “outside” কোনোটিই নয়) পায় না। “প্রতিটি পথে” প্রশ্ন বলে মিলনে ছেদ; একটি পথ খালি হলেই ফল খালি। শুধু শাখার ভেতরে else যোগ করলে তৃতীয় পথ বন্ধ হয়, আর error চলে যায়।

নিচের ব্লক দুটি কাজ করে। প্রথমে একটি ছোট ExtParser: var নাম : type ; পেলে initializer ছাড়া একটি Let বানায় (init=None), বাকি সব ক্ষেত্রে আগের parser-কেই ডাকে। তারপর DA pass, সংজ্ঞা ৫৪.২ হুবহু। Set-এ নাম নয়, binding-এর id রাখা হয়, যাতে shadowing-এ দুটি একই নামের variable গুলিয়ে না যায়। Resolver আগেই চলে, তাই নামের নিয়ম (decision 16 ইত্যাদি) তার কাজ।

// Haat-এর বর্ধিত রূপ: `var fee: Int;` — initializer ছাড়া ঘোষণা (fee.haat, অংশ)
fn charge(total: Int, zone: Str) -> Int {          // লাইন ২–১০
    var fee: Int;
    if zone == "dhaka" { fee = 60; } else if zone == "outside" { fee = 120; }
    return total + fee;
}
fn charge2(…)    // if/else দুই শাখাতেই fee বসে
fn charge3(…)    // if total >= 1000 { return total; } else { fee = 60; }
fn repeat_fee(n: Int) -> Int {                       // লাইন ২১–২৬
    var fee: Int;  var i = 0;
    while i < n { fee = 10 * i; i = i + 1; }
    return fee;
}
from haat_resolve import *        # parse, Parser, Resolver (পর্ব ৫১)
class ExtParser(Parser):          # Haat-এর বর্ধিত রূপ: `var x: T;` (initializer ছাড়া)
    def let_decl(self):
        save = self.pos; kw = self.advance(); name = self.advance()
        if kw.kind == "VAR" and self.match("COLON"):
            ann = self.parse_type()
            if self.match("SEMI"): return Let(name.text, True, ann, None, name.line, name.col)
        self.pos = save; return super().let_decl()    # বাকি সব: আগের মতোই
TOP = None                        # ⊤ = "এখানে পৌঁছানো যায় না", তাই সব assigned ধরা যায়
def meet(a, b): return b if a is TOP else a if b is TOP else a & b
class DA:                         # A = নিশ্চিতভাবে assigned binding-এর id-এর set
    def __init__(self, r): self.r, self.errors, self.tracked = r, [], set()
    def use(self, e, A):
        if isinstance(e, Var) and A is not TOP and id(self.r.uses.get(id(e))) in self.tracked - A:
            self.errors.append((e.line, e.col, f"variable '{e.name}' might not have been assigned"))
        if isinstance(e, Lambda): self.block(e.body.stmts, A)
        for x in [getattr(e, f) for f in ("operand", "left", "right", "callee") if hasattr(e, f)] + getattr(e, "args", []): self.use(x, A)
    def block(self, stmts, A):
        for s in stmts: A = self.stmt(s, A)
        return A
    def stmt(self, s, A):
        for e in (getattr(s, f, None) for f in ("init", "value", "cond", "expr")):
            if e is not None: self.use(e, A)
        if isinstance(s, Let) and s.init is None: self.tracked.add(id(self.r.decls[id(s)]))
        elif isinstance(s, Assign): return A if A is TOP else A | {id(self.r.uses[id(s)])}
        elif isinstance(s, Return): return TOP
        elif isinstance(s, FnDecl): self.block(s.body.stmts, A)
        elif isinstance(s, Block): return self.block(s.stmts, A)
        elif isinstance(s, If): return meet(self.block(s.then.stmts, A), A if s.else_ is None else self.stmt(s.else_, A))
        elif isinstance(s, While):                # body শূন্যবারও চলতে পারে, তাই পরে A
            self.block(s.body.stmts, A); return TOP if isinstance(s.cond, Bool) and s.cond.value else A
        return A
prog = ExtParser(tokenize(open("fee.haat", encoding="utf-8").read())).parse_program()
r = Resolver(); print("names:", r.program(prog) or "ok"); da = DA(r); da.block(prog.stmts, set())
for l, c, m in sorted(da.errors): print(f"{l}:{c}: error: {m}")

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

names: ok
9:20: error: variable 'fee' might not have been assigned
25:12: error: variable 'fee' might not have been assigned

চারটি function, দুটি error. charge (9:20): ছবি ৫৪.১-এর তৃতীয় পথ। charge2: দুই শাখাতেই মান, ছেদ {fee}, ঠিক আছে। charge3: then-শাখা return করে, তার ফল ⊤; ⊤ ⊓ {fee} = {fee}, তাই ঠিক আছে: যে পথে fee মান পায়নি, সেই পথ শেষ লাইনে পৌঁছায়ই না। Java-তেও ঠিক এই নিয়ম। repeat_fee (25:12): n শূন্য বা ঋণাত্মক হলে loop একবারও চলে না। মানুষ হয়তো জানে n সবসময় ধনাত্মক, কিন্তু check তা জানে না: এটি conservative হওয়ার দাম।

2fn charge(total: Int, zone: Str) -> Int {3    var fee: Int;4    if zone == "dhaka" {5        fee = 60;6    } else if zone == "outside" {7        fee = 120;8    }9    return total + fee;10}
DA-এর অবস্থা
tracked
A
শাখার ফল
  1. Function-এ ঢোকা. নতুন function-এর body, A = { }. Parameter total আর zone tracked নয়: parameter সবসময় মান নিয়ে আসে।
  2. var fee: Int; Initializer নেই, তাই fee-এর binding tracked set-এ যায়। A বদলায় না: fee এখনো কোনো পথে মান পায়নি।
  3. প্রথম শাখা. শর্ত zone == "dhaka" পড়ে শুধু zone, যা tracked নয়, তাই কোনো error নেই। Then-শাখায় fee = 60;: A ∪ {fee} = {fee}.
  4. else if. Else-অংশটি নিজেই একটি if. তার then-শাখায় fee = 120; → {fee}. তার কোনো else নেই, তাই else-এর ফল ঢোকার সময়ের A = { }. ভেতরের if-এর ফল {fee} ⊓ { } = { }.
  5. মিলন. বাইরের if-এর ফল then-এর {fee} আর else-এর { }-এর ছেদ: { }. তিনটি পথের একটিতে (দুটি শর্তই মিথ্যা) fee মান পায়নি।
  6. পড়া, আর error. return total + fee;-এ 9:20-এর fee tracked, কিন্তু A-তে নেই: error. তারপর return A-কে ⊤ বানায়। শেষ else { fee = 0; } যোগ করলে ধাপ ৪-এ else-এর ফল {fee} হতো, আর error থাকত না।

Hoisted function-এর ক্ষেত্রে এই pass reference-এর মতোই সীমিত। একটি top-level var k: Int; আর তার পরে লেখা fn show() -> Int { return k; }: pass function-এর body পরীক্ষা করে ঘোষণার জায়গার A দিয়ে, যেখানে k এখনো মান পায়নি, তাই error, যদিও সব ডাক হয়তো k = 5;-এর পরে। এটি Java-র lambda-র নিয়মের মতো (lambda-র body-তে বাইরের local variable তখনই পড়া যায়, যখন সেটি lambda-র আগেই নিশ্চিতভাবে assigned). আরও নিখুঁত হতে হলে interprocedural বিশ্লেষণ লাগে, যার খরচ অনেক বেশি; Haat reference একই কারণে runtime-এ not initialized yet দেখে।

৬ · Exhaustiveness আর constant expression

পর্ব ২৪-এ (Algebraic data type আর pattern matching) Haat-এর বর্ধিত রূপে enum আর match এসেছে, সঙ্গে flat enum-এর জন্য একটি সরল algorithm: সব constructor-এর set থেকে প্রতিটি arm যা ধরে তা বাদ, শেষে কিছু থাকলে error, যেমন 3:5: error: non-exhaustive match: missing 'Card'. সেখানে কথা দেওয়া হয়েছিল যে exhaustiveness এই পর্বে বাস্তবায়ন হবে। Flat enum সহজ; সমস্যা শুরু হয় যখন pattern-এর ভেতরে pattern থাকে।

বাজারঘরের ডেলিভারি: enum Zone { Dhaka, Outside } আর enum Ship { Pickup, Home(Zone, Bool) }, যেখানে Bool মানে express ডেলিভারি কি না। একটি match-এর arm: Pickup, Home(Dhaka, _), Home(_, true). Flat algorithm বলবে Home ধরা হয়েছে, কিন্তু Home(Outside, false) কোনো arm-এ মেলে না। সমাধান Luc Maranget-এর usefulness algorithm (তাঁর ২০০৭ সালের প্রবন্ধ “Warnings for pattern matching”; Rust আর OCaml-এর compiler এই ধারার algorithm ব্যবহার করে বলে জানা যায়)। মূল প্রশ্ন একটিই: “pattern q কি এমন কোনো মান ধরে, যা আগের সারিগুলোর (matrix P) কোনোটি ধরে না?” এক প্রশ্নে দুই check:

  • Redundancy: arm i-এর pattern যদি আগের arm-গুলোর তুলনায় useful না হয়, তবে সেটি একটি redundant pattern: warning unreachable match arm.
  • Exhaustiveness: সব arm-এর পরে _ (যেকোনো মান) useful হলে match অসম্পূর্ণ; algorithm সঙ্গে একটি উদাহরণ মানও ফেরত দেয়, যা কোনো arm-এ মেলে না।

Algorithm প্রথম কলাম ধরে চলে। q-এর প্রথম ঘর constructor c হলে P আর q দুটিকেই c দিয়ে “খোলা” হয় (spec): c-এর সারিগুলো থেকে c সরিয়ে তার ভেতরের ঘরগুলো সামনে আনা, অন্য constructor-এর সারি বাদ, আর _ হলে c-এর প্রতিটি field-এর জন্য একটি _. q-এর প্রথম ঘর _ হলে দুই পথ। P-এর প্রথম কলাম type-এর সব constructor ঢেকে ফেললে প্রতিটি constructor আলাদা করে চেষ্টা; না ঢাকলে শুধু _-ওয়ালা সারি রেখে (default matrix) বাকি কলামে যাওয়া, আর উদাহরণে একটি বাদ পড়া constructor বসানো।

"use strict";   // Haat-এর বর্ধিত রূপ: nested pattern-এর exhaustiveness (usefulness algorithm)
const TYPES = { Bool: { true: [], false: [] }, Zone: { Dhaka: [], Outside: [] },
                Ship: { Pickup: [], Home: ["Zone", "Bool"] } };          // constructor -> field type
function pat(s) {                 // "Home(Dhaka, _)" -> {c: "Home", args: [{c: "Dhaka"}, "_"]}
  const t = s.match(/\w+|[(),]/g); let i = 0;
  const one = () => { const w = t[i++]; if (w === "_") return "_";
    const args = []; if (t[i] === "(") { do { i++; args.push(one()); } while (t[i] === ","); i++; }
    return { c: w, args }; };
  return one();
}
const show = p => p === "_" ? "_" : p.args.length ? `${p.c}(${p.args.map(show).join(", ")})` : p.c;
function spec([h, ...rest], c, n) {   // সারির প্রথম ঘর c দিয়ে খোলা; না মিললে null
  return h === "_" ? [...Array(n).fill("_"), ...rest] : h.c === c ? [...h.args, ...rest] : null; }
function useful(P, q, tys) {      // q কি P-এর কোনো সারি না-ধরা মান ধরে? ধরলে উদাহরণ ফেরত
  if (q.length === 0) return P.length === 0 ? [] : null;
  const [ty, ...more] = tys, ctors = Object.keys(TYPES[ty]);
  const seen = new Set(P.map(r => r[0]).filter(h => h !== "_").map(h => h.c));
  const tryC = c => { const f = TYPES[ty][c], n = f.length;
    const w = useful(P.map(r => spec(r, c, n)).filter(Boolean), spec(q, c, n), [...f, ...more]);
    return w && [{ c, args: w.slice(0, n) }, ...w.slice(n)]; };
  if (q[0] !== "_") return tryC(q[0].c);
  const missing = ctors.filter(c => !seen.has(c));
  if (missing.length === 0) { for (const c of ctors) { const w = tryC(c); if (w) return w; } return null; }
  const w = useful(P.filter(r => r[0] === "_").map(r => r.slice(1)), q.slice(1), more);
  return w && [{ c: missing[0], args: TYPES[ty][missing[0]].map(() => "_") }, ...w];
}
function check(arms) {            // Ship-এর ওপর match: প্রতিটি arm, তারপর পুরো match
  const rows = [];
  for (const [i, a] of arms.entries()) { const p = pat(a);
    console.log(`arm ${i + 1} ${a.padEnd(20)}`, useful(rows, [p], ["Ship"]) ? "ok" : "warning: unreachable match arm");
    rows.push([p]); }
  const w = useful(rows, ["_"], ["Ship"]); console.log(w ? `error: non-exhaustive match: missing '${show(w[0])}'` : "exhaustive");
}
check(["Pickup", "Home(Dhaka, _)", "Home(_, true)"]);
check(["Pickup", "Home(Dhaka, _)", "Home(_, true)", "Home(Outside, false)", "Home(Dhaka, true)"]);

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

arm 1 Pickup               ok
arm 2 Home(Dhaka, _)       ok
arm 3 Home(_, true)        ok
error: non-exhaustive match: missing 'Home(Outside, false)'
arm 1 Pickup               ok
arm 2 Home(Dhaka, _)       ok
arm 3 Home(_, true)        ok
arm 4 Home(Outside, false) ok
arm 5 Home(Dhaka, true)    warning: unreachable match arm
exhaustive

প্রথম match-এ তিনটি arm-ই নতুন কিছু ধরে, কিন্তু শেষে _ এখনো useful, আর algorithm উদাহরণ দেয় Home(Outside, false): বাইরের জেলায় সাধারণ ডেলিভারি কেউ সামলায়নি। এটিই Rust-এর error-এর “patterns not covered” অংশের মতো, একটি নির্দিষ্ট উদাহরণ। দ্বিতীয় match-এ চতুর্থ arm সেই ফাঁক বন্ধ করে, তাই match সম্পূর্ণ। পঞ্চম arm Home(Dhaka, true) আগেই Home(Dhaka, _)-এ ধরা পড়েছে: redundant. Bool-কে এখানে দুটি constructor (true, false)-ওয়ালা type ধরা হয়েছে; Int বা Str-এর অসীম মান থাকায় সেখানে শুধু _ সব ঢাকে। Guard-ওয়ালা arm matrix-এ যোগই হয় না (পর্ব ২৪-এর নিয়ম): guard মিথ্যাও হতে পারে।

Constant expression. কিছু ভুল compile-এর সময়েই নিশ্চিত, কারণ সংশ্লিষ্ট সব মান literal. Haat-এর lexer একটি ধরে: 9223372036854775807-এর চেয়ে বড় integer literal একটি lexical error (decision 3). আরেকটি সম্ভাব্য check: x / 0 বা x % 0, যেখানে ভাজক literal শূন্য। Reference এটি static-ভাবে ধরে না; চলার সময় runtime error: division by zero দেয়, ঠিক / চিহ্নের অবস্থানে (decision 24). একটি constant folding pass সহজেই এর আগাম warning দিতে পারত, যেমন Clang ডিফল্টেই দেয় (অংশ ৭)। আর Haat-এ 9223372036854775807 + 1 সংজ্ঞায়িত (wrap করে, decision 13), তাই সেখানে error দেওয়া ভুল হতো; সর্বোচ্চ একটি warning. C17-এ signed overflow undefined behavior, তাই Clang-এর -Winteger-overflow সেখানে অনেক বেশি অর্থবহ। C-তে constant expression আরও কাজে লাগে: case-এর label আর global array-এর মাপ constant হতেই হবে; Java-তে একই case দুবার থাকলে error.

৭ · সত্যিকারের compiler-এ — Clang আর javac

একই চার ধরনের ভুল এবার একটি C ফাইলে আর একটি Java ফাইলে, দুটি সত্যিকারের compiler-এ। C (সত্যিকারের run: PyPI ziglang 0.17.1-এর সঙ্গে আসা clang 22.1.8, x86_64 Windows target; প্রতিটি diagnostic-এর প্রথম লাইন রেখে ট্রিম করা):

enum zone { DHAKA, OUTSIDE, ABROAD };
int zone_fee(enum zone z) {                         // 2
    switch (z) { case DHAKA: return 60; case OUTSIDE: return 120; }
    return 0;
}
int charge(int total, int z) {                      // 9
    int fee;
    if (z == 0) fee = 60;
    else if (z == 1) fee = 120;
    return total + fee;
}
int discount(int total) {                           // 15
    int vat = 15;  int note = 0;  note = 1;
    return total / 10;
    total = 0;
}
int retry(void) {                                   // 22
    int tries = 0;  tries = tries + 1;
    int left = 3;   left -= 1;
    return 7 / 0;
}
int debug(void) { if (0) return 1; while (0) { return 2; } return 3; }
~/sem $ python -m ziglang cc -c -o checks.o -Wall -Wextra -Wunreachable-code checks.c
checks.c:3:13: warning: enumeration value 'ABROAD' not handled in switch [-Wswitch]
checks.c:12:14: warning: variable 'fee' is used uninitialized whenever 'if' condition is false [-Wsometimes-uninitialized]
checks.c:16:9: warning: unused variable 'vat' [-Wunused-variable]
checks.c:17:9: warning: variable 'note' set but not used [-Wunused-but-set-variable]
checks.c:20:13: warning: code will never be executed [-Wunreachable-code]
checks.c:25:9: warning: variable 'left' set but not used [-Wunused-but-set-variable]
checks.c:27:14: warning: division by zero is undefined [-Wdivision-by-zero]
7 warnings generated.

(Run-এর ফাইলে প্রতিটি statement নিজের লাইনে ছিল; ওপরে জায়গা বাঁচাতে কয়েকটি এক লাইনে রাখা, তাই line নম্বর মূল ফাইলের।) লক্ষ করার মতো ছয়টি বিষয়:

  1. সবই warning. C-র standard এগুলোর কোনোটিকে error বলে না; ফাইলটি compile হয়েছে, checks.o তৈরি।
  2. কোনটি কখন চালু. একই ফাইল কোনো flag ছাড়া চালালে শুধু দুটি আসে: -Wswitch আর -Wdivision-by-zero. -Wall যোগ করলে আসে uninitialized আর unused-এর চারটি। -Wunreachable-code -Wall-এও নেই; আলাদা চাইতে হয় (তিনটি run-ই সত্যিকারের)।
  3. Definite assignment-এর আত্মীয়. -Wsometimes-uninitialized বলে ঠিক কোন শর্ত মিথ্যা হলে fee মান পায় না, আর পরের note-গুলো (ট্রিম করা) দেখায় ব্যবহারের জায়গা 13:20, ছবি ৫৪.১-এর তৃতীয় পথ।
  4. Constant শর্তে চুপ. debug-এর if (0) আর while (0)-এ কোনো warning আসেনি। Clang ইচ্ছা করে literal শর্তকে “configuration”-এর মতো ধরে নেয় বলে মনে হয়; Haat-এর pass while false-এ বলে, Java-ও বলে।
  5. tries চুপ, left ধরা পড়ে. tries = tries + 1-এ ডান পাশের পড়াকে Clang ব্যবহার হিসেবে গোনে, কিন্তু compound assignment left -= 1-কে নয়। পাতার pass-এর সীমার সঙ্গে হুবহু মিল।
  6. Exhaustiveness. enum-এর switch-এ ABROAD বাদ পড়লে warning ডিফল্টেই চালু।

Java (সত্যিকারের run: Wandbox-এর OpenJDK 21, openjdk-jdk-21+35; একই চার ভুল):

class Main {
    enum Zone { DHAKA, OUTSIDE, ABROAD }
    static int charge(int total, int z) {
        int fee;
        if (z == 0) fee = 60;
        else if (z == 1) fee = 120;
        return total + fee;                                  // 7
    }
    static int discount(int total) { return total / 10;      // 10
        total = 0; }                                         // 11
    static void debug() {
        if (false) { System.out.println("debug"); }          // 14
        while (false) { System.out.println("loop"); }        // 15
    }
    static int zoneFee(Zone z) {
        return switch (z) { case DHAKA -> 60; case OUTSIDE -> 120; };   // 18
    }
    public static void main(String[] args) { }
}
prog.java:11: error: unreachable statement
prog.java:15: error: unreachable statement
prog.java:18: error: the switch expression does not cover all possible input values
prog.java:7: error: variable fee might not have been initialized
4 errors

(মূল ফাইলে প্রতিটি statement নিজের লাইনে; মন্তব্যের নম্বরগুলো সেই ফাইলের।) চারটিই error, warning নয়। if (false)-এর লাইন ১৪ নিয়ে কিছু নেই, অথচ while (false)-এর body error: Java-র specification এই পার্থক্য ইচ্ছা করে রেখেছে, যাতে static final boolean DEBUG = false; আর if (DEBUG) { … } দিয়ে C-র #ifdef-এর মতো কোড চালু-বন্ধ করা যায়। একটি দ্বিতীয় run আরও দুটি কথা নিশ্চিত করেছে: while (true) { if (n > 0) return n; n = n + 1; }-ওয়ালা int method-এ পরে কোনো return না থাকলেও javac কোনো error দেয়নি আর চালালে উত্তর এসেছে, কিন্তু সেই লুপের পরে একটি println রাখলে error: unreachable statement. আর if (n > 0) return n / 2;-এর পরে কিছু না থাকলে error: missing return statement. অর্থাৎ Java-র missing return আর reachability একই নিয়ম; Haat-এর decision 21 আলাদা, আরও সরল আর কড়া।

javac-এর error-এর ক্রমও লক্ষ করার মতো: লাইন ৭-এর error সবার শেষে। Unreachable আর exhaustiveness একটি বিশ্লেষণে আসে, definite assignment পরের আরেকটি বিশ্লেষণে; প্রতিটি নিজের error ফাইলের ক্রমে দেয়। Haat reference-এর decision 2-এর মতো “সব error অবস্থান ধরে সাজানো” javac করে না।

৮ · Pass-গুলো যাচাই — ২০,০০০ random program

কয়েকটি উদাহরণে ঠিক উত্তর দেখে একটি static check-কে বিশ্বাস করা যায় না। এখানে reference-এর সঙ্গে হুবহু মেলানোর মতো কিছু নেই (reference warning দেয় না), তাই ল্যাবে দুই রকম যাচাই চালানো হয়েছে: reference-এর যে অংশ একই প্রশ্নের উত্তর দেয় তার সঙ্গে differential test, আর চলার সময়ের আচরণের সঙ্গে তুলনা। একটি generator (seed 54) ২০,০০০টি random Haat function বানায়: if/else, তিনবার ঘোরা while, while true, while false, return, print, assignment, আর বর্ধিত রূপের জন্য var x: Int;. প্রতিটি function ছয় জোড়া ইনপুটে চালানো হয়।

~/sem $ python -B tests.py 20000      (অংশ, সাজানো)
T1 lists: 103245   agree: 100448   page-dead, ref-not-returns (while true): 2797
T1 ref-returns but page-live (must be 0): 0     other disagreements (must be 0): 0
T2 programs: 16848 (failing check, skipped: 3152)   warnings: 12609
T2 flagged but executed (must be 0): 0   mini evaluator != reference output (must be 0): 0
T3 accepted: 5694   accepted: unset read at run time (must be 0): 0
T3 rejected: 3170   rejected: unset read at run time: 2145
T4 programs edited: 8984   warnings: 18080 unused + 1921 never read
T4 deletion broke check (must be 0): 0   output changed (must be 0): 0
  • T1, reference-এর সঙ্গে. প্রতিটি statement তালিকায় (মোট ১,০৩,২৪৫টি) পাতার reach আর reference-এর always_returns তুলনা। Reference “প্রতিটি পথে return” বললে পাতার pass একবারও “শেষ হয়” বলেনি। উল্টো দিকের ২,৭৯৭টি অমিলের প্রতিটিতে একটি while true: অংশ ৩-এর সেই ইচ্ছাকৃত পার্থক্য, আর কিছু নয়।
  • T2, চলার সময়ের সঙ্গে. Reference-এর check পার হওয়া ১৬,৮৪৮টি program-এ ১২,৬০৯টি unreachable warning; একটি ছোট evaluator প্রতিটি চলা statement-এর অবস্থান লিখে রাখে (আর তার আউটপুট reference-এর run-এর সঙ্গে প্রতিটি program-এ হুবহু মিলেছে)। Warning পাওয়া একটি statement-ও কখনো চলেনি: warning-এর দাবি সবসময় সত্য।
  • T3, definite assignment. ৮,৮৬৪টি program-এ initializer-হীন var. যে ৫,৬৯৪টি গ্রহণ করা হয়েছে, তার একটিও চলার সময় মান-না-বসা variable পড়েনি: পরীক্ষায় sound. আটকানো ৩,১৭০টির ২,১৪৫টি সত্যিই পড়েছে; বাকি ১,০২৫টি ছয় ইনপুটে পড়েনি: সেগুলো false alarm, অথবা অন্য ইনপুটে ভুলটি ঘটত। এটিই সংজ্ঞা ৫৪.১-এর আপস, সংখ্যায়।
  • T4, unused-এর দাবি. Warning পাওয়া প্রতিটি variable-এর ঘোষণা (আর “never read” হলে তার assignment-ও) মুছে reference-এ আবার check আর run: ৮,৯৮৪টি program-এর একটিতেও check ভাঙেনি বা আউটপুট বদলায়নি। (Generator-এর initializer-এ function call নেই; call থাকলে মুছলে side effect হারাত, তাই বাস্তব tool এমন মোছা নিজে করে না।)

একটি সংখ্যা ইচ্ছা করে নেই: “পাতার pass কতটা মৃত কোড ধরতে পারেনি”. Random input-এ একটি statement না চলা মানে সেটি মৃত নয়; সত্যিকারের মৃত কোড নির্ভুলভাবে গোনা আবার সেই undecidable প্রশ্ন। Testing-এর এই কৌশল নিয়ে আরও Software Testing কোর্সের পর্ব ৬০-এ।

আরও গভীরে: javac-এর ভেতরে Flow নামের ধাপে কয়েকটি আলাদা বিশ্লেষক আছে: reachability-র জন্য একটি, definite assignment-এর জন্য আরেকটি; error-এর ক্রমের কারণ এটাই (অংশ ৭)। Java-র নিয়মে && আর ||-এর জন্য দুটি আলাদা set রাখা হয়: “শর্ত সত্য হলে assigned” আর “মিথ্যা হলে assigned”, কারণ Java-তে expression-এর ভেতরেও assignment থাকতে পারে; Haat-এ assignment statement (decision 9), তাই একটি set-ই যথেষ্ট। Clang-এর uninitialized warning parse-এর পরে প্রতিটি function-এর CFG-র ওপর চলা একটি dataflow analysis, optimizer-এর আগে। আর সাধারণ ক্ষেত্রে nested pattern-এর exhaustiveness NP-complete বলে পরিচিত, তবু বাস্তব program-এর match ছোট হওয়ায় algorithm দ্রুত চলে।

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

  • Definite assignment কী? Local variable পড়ার আগে প্রতিটি পথে মান বসেছে কি না, compile-এর সময় যাচাই; Java-তে না পারলে error, শাখা মিললে ছেদ নেওয়া হয়।
  • Compiler কেন সব unreachable code ধরতে পারে না? “এই statement কখনো চলবে কি না” আচরণ-সংক্রান্ত প্রশ্ন, যা Rice-এর theorem অনুযায়ী সাধারণভাবে undecidable; তাই কাঠামো-ভিত্তিক conservative নিয়ম।
  • Sound আর complete check-এর পার্থক্য? Sound কোনো আসল ভুল ছাড়ে না, complete কোনো ঠিক program আটকায় না; দুটি একসঙ্গে সাধারণত অসম্ভব।
  • Pattern match-এর exhaustiveness কীভাবে যাচাই হয়? Usefulness: সব arm-এর পরে wildcard এখনো কোনো মান ধরলে match অসম্পূর্ণ, আর সেই মানই উদাহরণ; কোনো arm আগের arm-গুলোর তুলনায় useful না হলে সেটি redundant.
  • Warning আর error-এর পার্থক্য? Error-এ program তৈরি হয় না, নিয়ম specification-এ লেখা; warning শুধু সতর্কতা, compiler-ভেদে আলাদা, flag দিয়ে চালু-বন্ধ।

৯ · AI-এর যুগে semantic check

“আমার ভাষার জন্য একটি unreachable code checker লিখে দাও” চাইলে AI assistant একটি চলনসই pass দেবে। ভুলগুলো থাকে নিয়মের কিনারায় আর অন্য ভাষার দাবিতে:

AI-এর ভুলকীভাবে ধরবেন
“Java-তে if (false)-এর body unreachable error” বা “C compiler unreachable code-এ error দেয়”: এক ভাষার নিয়ম অন্যটিতেদুটি compiler-এ সত্যিকারের run (অংশ ৭); JLS বা compiler-এর documentation
Definite assignment-এ শাখা মিললে union (∪) নেওয়া, বা loop-এর body-কে নিশ্চিতভাবে চলা ধরাRandom program চালিয়ে মান-না-বসা পড়া গোনা (অনুশীলন ২)
return থাকা শাখাকে মিলনে খালি set ধরা, ফলে ঠিক program-এ false alarmcharge3-এর মতো test: একটি শাখা return করে
“-Wall সব warning চালু করে” বা অস্তিত্বহীন flagFlag ছাড়া, -Wall, আর আলাদা flag-এ তিনবার চালিয়ে দেখা
Exhaustiveness-এ guard-ওয়ালা arm গোনা, বা nested pattern-এ শুধু বাইরের constructor দেখাHome(Outside, false)-এর মতো nested ফাঁকের test
Unused variable মুছে ফেলার পরামর্শ, initializer-এর side effect ভুলেমোছার আগে-পরে program চালিয়ে আউটপুট মেলানো (T4-এর মতো)

ভালো উপায়: নিয়মগুলো নিজে লিখে দিন, কোন দিকে ভুল করা চলবে তা স্পষ্ট বলুন, আর কোডের সঙ্গে test চান।

আমি Haat নামের একটি ছোট ভাষার জন্য definite assignment check লিখছি (Python 3). AST class নিচে দিলাম; resolver আগেই প্রতিটি নামকে binding-এ জুড়েছে। ১. var x: T; (initializer ছাড়া) ঘোষিত variable "tracked"; পড়ার আগে প্রতিটি পথে মান বসা চাই, নাহলে "variable 'x' might not have been assigned". ২. if/else-এর মিলনে ছেদ নাও; return-এর পরের অবস্থা "সব assigned" (⊤), আর ⊤ ⊓ S = S. ৩. while-এর পরে শুধু ঢোকার আগের set; শর্ত literal true হলে ⊤। ৪. check-টি sound হতে হবে: সন্দেহ হলে error দাও। কোথায় এটি ঠিক program-ও আটকাবে, তার দুটি উদাহরণ দাও। ৫. কোডের পরে ৮টি test দাও: else ছাড়া if, else if, এক শাখায় return, while, নিজের নাম shadow করা, lambda — প্রত্যাশিত আউটপুটসহ। ৬. Java বা C# কী করে তা নিয়ে নিশ্চিত না হলে "নিশ্চিত নই" লেখো। [এখানে AST class]

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

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

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

প্র ০১Java unreachable code-কে error বানাল, C আর C++ রাখল warning-এ, আর Go unused variable-কেও error করল। কোন যুক্তিতে, আর কার দাম কে দেয়?

Java ১৯৯০-এর দশকের মাঝামাঝি নকশা করা হয়েছিল এমন একটি ভাষা হিসেবে যা প্রোগ্রামারকে নিরাপদ পথে রাখবে: memory-র সরাসরি নিয়ন্ত্রণ নেই, array-র সীমা পরীক্ষা হয়, আর local variable পড়ার আগে মান বসার প্রমাণ লাগে। সেই দর্শনে unreachable statement একটি নিশ্চিত ভুলের চিহ্ন: কেউ এমন কোড লিখেছেন যা কখনো চলবে না, আর প্রায় সবসময় তার কারণ অন্য কোথাও একটি ভুল return বা ভুল শর্ত। Error বানালে সমস্যাটি উপেক্ষা করা যায় না। তবে এর একটি দাম আছে, আর Java সেটি জানত: debug কোড সাময়িকভাবে বন্ধ রাখা। তাই specification if (false)-কে ছাড় দিয়েছে, কিন্তু while (false)-কে দেয়নি; অংশ ৭-এর সত্যিকারের run দুটিই দেখিয়েছে।

C-র ইতিহাস উল্টো। ১৯৭০-এর দশকের C ছিল একটি পাতলা, বিশ্বাসী ভাষা, আর standard compiler-কে প্রায় কোনো static বিশ্লেষণ বাধ্য করে না। তার ওপর preprocessor আর macro: একটি macro খুললে প্রায়ই এমন কোড তৈরি হয় যার একটি অংশ সেই নির্দিষ্ট ব্যবহারে কখনো চলে না। এমন কোডে error দিলে বৈধ, ভালো লাইব্রেরিও compile হতো না। তাই এখানে warning, আর -Wunreachable-code -Wall-এও নেই। Clang-এর literal শর্তে চুপ থাকা (if (0)) এই একই বাস্তবতার ফল।

Go (২০০৯) আরেক ধাপ এগিয়েছে: ব্যবহার না হওয়া local variable আর import দুটিই compile error. যুক্তি ছিল বড় codebase-এর দীর্ঘমেয়াদি স্বাস্থ্য: অব্যবহৃত import build-কে ধীর করে, আর warning-কে মানুষ সময়ের সঙ্গে উপেক্ষা করতে শেখে। দাম দেন প্রোগ্রামার, কোড লেখার মাঝপথে: একটি লাইন comment করলেই অন্য জায়গায় error, তাই _ = x-এর মতো কৌশল লাগে। Rust মাঝামাঝি পথ নিয়েছে: warning, কিন্তু ডিফল্টে চালু, আর _ দিয়ে শুরু নাম বা #[allow(unused)] দিয়ে ঘোষিতভাবে চুপ করানো।

দাম কার ঘাড়ে পড়ে, সেটিই আসল প্রশ্ন। কড়া নিয়মে দাম দেন লেখক, প্রতিদিন, অল্প অল্প করে। ঢিলা নিয়মে দাম দেন পাঠক আর রক্ষণাবেক্ষণকারী, পরে, কখনো একটি বড় bug-এর রূপে। Haat একটি শেখার ভাষা; তার reference-এ warning না থাকাটাও একটি সিদ্ধান্ত: v1-এর নিয়ম ছোট আর পরীক্ষাযোগ্য রাখা।

মূল উপলব্ধি: একই check error, warning বা নীরব হতে পারে; সিদ্ধান্তটি প্রযুক্তির নয়, ভাষার দর্শনের, আর তার দাম কোনো না কোনো মানুষ দেন।

প্র ০২মান না বসা variable পড়া — C, Java, JavaScript আর Haat চারটি ভিন্ন উত্তর দেয়। প্রতিটি উত্তর compile-এর সময় আর চলার সময়ের মধ্যে কাজ কীভাবে ভাগ করে?

C17-এ একটি automatic variable-এর মান ঘোষণার পরে অনির্ধারিত, আর কিছু অবস্থায় সেটি পড়া undefined behavior. Compiler-এর কোনো বাধ্যবাধকতা নেই, চলার সময়েও কোনো পরীক্ষা নেই। এর লাভ গতি: কোনো বাড়তি কাজ নেই। ক্ষতি নিরাপত্তায়: পুরোনো stack-এর আবর্জনা পড়া হতে পারে, আর optimizer undefined behavior ধরে নিয়ে কোড এমনভাবে বদলাতে পারে যা উৎস দেখে বোঝা কঠিন। Clang-এর -Wsometimes-uninitialized একটি সহায়তা, নিয়ম নয়।

Java সব কাজ compile-এর সময়ে নিয়ে গেছে। JLS-এর chapter 16 একটি পুরোপুরি কাঠামো-ভিত্তিক নিয়ম: প্রতিটি statement আর expression-এর জন্য “আগে কী assigned, পরে কী assigned”. যেহেতু নিয়মটি specification-এ লেখা, প্রতিটি Java compiler একই program একইভাবে আটকায়। চলার সময় কোনো পরীক্ষা লাগে না, কারণ প্রমাণ আগেই হয়ে গেছে; আর heap-এর field-এর জন্য Java ডিফল্ট মান (শূন্য, null) দেয়, তাই প্রশ্ন শুধু local variable-এর। দাম: কিছু ঠিক program আটকায়, যেমন এই পর্বের repeat_fee, যেখানে মানুষ জানে loop অন্তত একবার চলবে।

JavaScript-এর let সব কাজ চলার সময়ে রেখেছে: ঘোষণা চলার আগে নামটি TDZ-এ, ছুঁলে ReferenceError. কোনো program compile-এর সময় আটকায় না, তাই কোনো ঠিক program-ও আটকায় না: complete, কিন্তু ভুল ধরা পড়ে শুধু সেই পথ চললে। Engine-কে প্রতিটি পড়ায় পরীক্ষা করতে হতে পারে, যদিও JIT অনেক পরীক্ষা সরিয়ে দিতে পারে যখন প্রমাণ করা যায় যে প্রয়োজন নেই।

Haat দুই ভাগে ভাগ করেছে। Initializer বাধ্যতামূলক, ঘোষণার আগে ব্যবহার static error (decision 16), তাই local variable-এর সমস্যাটি নকশা দিয়েই প্রায় নেই। বাকি একটি ফাঁক, hoisted function-এর মাধ্যমে top-level variable তৈরির আগে পড়া, চলার সময় not initialized yet দিয়ে ধরা (decision 18, 26). কারণ: সেটি static-ভাবে নিখুঁতভাবে ধরতে পুরো program-এর call graph আর চলার ক্রম লাগে, যা সাধারণভাবে undecidable; আর conservative নিয়ম দিলে mutual recursion-এর মতো সুন্দর ব্যবহারও আটকাত। এই পর্বের বর্ধিত রূপের var fee: Int; Java-র পথে আরেক ধাপ।

মূল উপলব্ধি: একই ভুল ঠেকানোর কাজ compile-এর সময় আর চলার সময়ের মধ্যে যেকোনো অনুপাতে ভাগ করা যায়; static দিক sound কিন্তু কড়া, dynamic দিক নিখুঁত কিন্তু দেরিতে, আর ভালো নকশা দুটিকে মেশায়।

প্র ০৩Rice-এর theorem বলে নিখুঁত check অসম্ভব। তাহলে Java-র definite assignment কীভাবে “সব compiler-এ একই” হতে পারে, আর Clang-এর warning কেন version-ভেদে বদলায়?

Rice-এর theorem (Henry Gordon Rice, ১৯৫৩) বলে, program যে আচরণ করে তার যেকোনো non-trivial ধর্ম সাধারণভাবে undecidable. “এই variable কি কোনো চলায় মান ছাড়া পড়া হবে?” এমন একটি ধর্ম। কিন্তু theorem বলে না যে কোনো উপযোগী নিয়মই সম্ভব নয়; বলে, নিয়মটি আচরণের প্রশ্নের নিখুঁত উত্তর হতে পারবে না। সমাধান হলো প্রশ্ন বদলে ফেলা: আচরণের বদলে কাঠামো নিয়ে প্রশ্ন। “Program-এর গঠন অনুযায়ী প্রতিটি পথে, প্রতিটি শর্তকে অজানা ধরে, মান বসেছে কি?” এই প্রশ্ন decidable, দ্রুত, আর আচরণের প্রশ্নের একটি নিরাপদ অনুমান।

Java ঠিক এটি করেছে, আর নিয়মটি specification-এ লিখে দিয়েছে। তাই definite assignment আসলে Java ভাষার নিয়মের অংশ, compiler-এর বুদ্ধির নয়: দুটি compiler একই program-এ ভিন্ন সিদ্ধান্ত দিলে অন্তত একটি ভুল। এর জন্য নিয়মটিকে ইচ্ছা করে “বোকা” রাখতে হয়েছে: শর্তের মান দেখা হয় না, শুধু constant expression ছাড়া (while (true), if (false)-এর বিশেষ নিয়ম)। x > 0 আর x <= 0 দুটি শাখা মিলে সব ক্ষেত্র ধরলেও Java তা জানে না।

Clang-এর warning-এর কোনো specification নেই। সেখানে বিশ্লেষণ যত চতুর হতে পারে: CFG-র ওপর dataflow, কোন শর্ত মিথ্যা হলে সমস্যা তার ব্যাখ্যা, macro আর constant নিয়ে নানা heuristic. প্রতিটি নতুন version-এ এগুলো উন্নত হয়, তাই warning-এর তালিকা বদলায়, আর -Werror দিয়ে build করা প্রকল্প compiler আপডেটে হঠাৎ ভেঙে যেতে পারে। GCC-র কিছু uninitialized warning-এর ক্ষেত্রে GCC-র documentation নিজেই সতর্ক করে যে ফল optimization-এর স্তরের ওপর নির্ভর করতে পারে, কারণ সেই বিশ্লেষণ optimizer-এর তথ্য ব্যবহার করে।

এই পর্বের Haat pass-গুলো Java-র ধারার: কাঠামো-ভিত্তিক, ছোট, পূর্বানুমেয়। ২০,০০০ program-এর পরীক্ষা দেখিয়েছে দাম কত: definite assignment ৩,১৭০টি program আটকেছে, তার ১,০২৫টি ছয়টি ইনপুটে কোনো সমস্যা দেখায়নি। নিয়ম আরও চতুর করলে এই সংখ্যা কমত, কিন্তু নিয়ম বোঝানো আর specification-এ লেখা কঠিন হতো।

মূল উপলব্ধি: undecidability এড়ানো হয় প্রশ্ন বদলে; ভাষার নিয়ম হলে সেই সহজ প্রশ্ন specification-এ বাঁধা থাকে, warning হলে compiler তাকে যত খুশি চতুর করতে পারে, অস্থিরতার দামে।

প্র ০৪বাজারঘর কাল থেকে Nagad নেবে। Exhaustiveness check থাকা আর না থাকা ভাষায় এই পরিবর্তনের যাত্রা কেমন আলাদা, আর _ => arm কেন দুধারী?

Exhaustiveness check-এর আসল মূল্য কোড প্রথমবার লেখায় নয়, বদলানোয়। একটি enum Payment-এ নতুন constructor Nagad যোগ হলো। যে ভাষায় match সম্পূর্ণ হতেই হবে (Rust, Java 21-এর switch expression, OCaml-এ warning হিসেবে), compiler সঙ্গে সঙ্গে প্রতিটি অসম্পূর্ণ match-এর তালিকা দেয়: ফি হিসাব, রসিদ ছাপা, refund-এর নিয়ম। প্রোগ্রামার একটি একটি করে সামলান, আর তালিকা খালি হলে কাজ শেষ, অন্তত এই দিক থেকে। Exhaustiveness ছাড়া ভাষায় (Python-এর match, C-র switch ডিফল্ট flag ছাড়া) একই কাজ মানে grep, কোড রিভিউ, আর আশা; একটি জায়গা বাদ পড়লে Nagad-এর পেমেন্ট হয়তো নীরবে ফি শূন্য পায়।

ঠিক এখানেই _ => arm দুধারী। match pay { Cash => …, _ => 50 } সম্পূর্ণ, তাই compiler খুশি। কিন্তু Nagad এলে সেটিও _-এ পড়বে, কোনো error ছাড়া, ৫০ টাকা ফি নিয়ে, যা হয়তো ভুল। অর্থাৎ wildcard exhaustiveness check-কে চুপ করায়, ভবিষ্যতের জন্যও। অনেক দল তাই নিয়ম রাখে: নিজেদের enum-এ wildcard নয়, প্রতিটি constructor নাম ধরে লেখা। Java-তে sealed interface-এর switch-এ সব subclass নাম ধরে লিখলে নতুন subclass যোগ হলে compile error আসে; default লিখলে আসে না।

উল্টো সমস্যাও আছে। লাইব্রেরির লেখক চাইতে পারেন ভবিষ্যতে constructor যোগ করার স্বাধীনতা, ব্যবহারকারীদের কোড না ভেঙে। Rust এর জন্য #[non_exhaustive] চিহ্ন দেয়: তখন লাইব্রেরির বাইরের match-এ wildcard বাধ্যতামূলক। অর্থাৎ একই type-এর জন্য “বন্ধ” না “খোলা”, এটি লেখকের ঘোষিত সিদ্ধান্ত, আর exhaustiveness check সেটি মেনে চলে।

Algorithm-এর দিক থেকে nested pattern-এ খরচ তাত্ত্বিকভাবে বড় হতে পারে; সাধারণ ক্ষেত্রে সমস্যাটি NP-complete বলে পরিচিত। Maranget-এর usefulness algorithm এই পর্বের JavaScript ব্লকের মতো কলাম ধরে চলে আর বাস্তব match-এ দ্রুত। আর যেখানে মান অসীম (Int, Str), সেখানে শুধু wildcard সম্পূর্ণতা দেয়, তাই Card(0), Card(1) লিখে কখনো শেষ করা যায় না।

মূল উপলব্ধি: exhaustiveness check নতুন constructor যোগ করাকে একটি compiler-চালিত তালিকায় পরিণত করে; wildcard সেই তালিকা থেকে জায়গাটি মুছে দেয়, তাই সেটি ভেবেচিন্তে লেখা উচিত।

প্র ০৫একটি প্রকল্পে ৮০০টি warning জমে আছে। Warning-এর সংস্কৃতি কেন ভেঙে পড়ে, আর Haat-এ warning যোগ করার সময় কোন নীতি মানা উচিত?

Warning-এর মূল্য তার বিশ্বাসযোগ্যতায়। যদি ১০টির ৯টি false positive হয়, প্রোগ্রামাররা শেখেন সেগুলো উপেক্ষা করতে, আর দশমটি, যেটি আসল bug, অন্যদের ভিড়ে হারিয়ে যায়। ৮০০টি জমে থাকা warning-এর প্রকল্পে নতুন একটি warning কেউ লক্ষই করে না। এই কারণেই বাস্তব compiler-এর অনেক বিশ্লেষণ ডিফল্টে বন্ধ (Clang-এর -Wunreachable-code), আর যেগুলো চালু সেগুলোর false positive খুব কম।

প্রকল্পগুলো কয়েকটি কৌশলে এর মোকাবিলা করে। প্রথমত, -Werror বা CI-তে “নতুন warning চলবে না”: সংখ্যা শূন্যে রাখা, যাতে প্রতিটি নতুন warning চোখে পড়ে। দ্বিতীয়ত, চুপ করানোর ঘোষিত উপায়: C++17-এর [[maybe_unused]], Rust-এর _ নাম আর #[allow(…)], Python linter-এর লাইনভিত্তিক মন্তব্য। এগুলো warning-কে কারণসহ বন্ধ করে, আর কোড রিভিউতে সেই কারণ দেখা যায়। তৃতীয়ত, কিছু check compiler থেকে সরিয়ে আলাদা linter-এ রাখা (clang-tidy, Ruff, pyflakes), যাতে compiler-এর warning কম কিন্তু নির্ভরযোগ্য থাকে, আর দল নিজে বেছে নেয় কোন lint নিয়ম তাদের জন্য।

Haat-এ এই পর্বের warning-গুলো বর্ধিত রূপ হিসেবে যোগ করলে কয়েকটি নীতি স্বাভাবিক। Warning-এর আকার error-এর মতো (line:col: warning: …), যাতে tool আর মানুষ একইভাবে পড়েন। Error থাকলে warning নয় (decision 2-এর ধারা): ভাঙা program-এ warning প্রায়ই বিভ্রান্তিকর। প্রতিটি warning-এর দাবি সত্য হতে হবে: unreachable warning পাওয়া কোড সত্যিই কখনো চলে না (অংশ ৮-এর T2). চুপ করানোর একটি উপায়: _ দিয়ে শুরু নাম। আর warning কখনো program-এর আচরণ বদলায় না: run আর vm আগের মতোই।

শেষে, golden file. Warning-এর লেখা বা অবস্থান সামান্য বদলালেও IDE, CI script আর মানুষের অভ্যাস ভাঙে। Reference-এর .out ফাইলের মতো warning-এরও golden file রাখলে প্রতিটি পরিবর্তন সচেতন সিদ্ধান্ত হয়।

মূল উপলব্ধি: warning একটি যোগাযোগের মাধ্যম; তার শক্তি সংখ্যায় নয়, বিশ্বাসে, তাই কম কিন্তু নির্ভুল warning অনেক ঝাপসা warning-এর চেয়ে বেশি কাজের।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট পাতার pass বা Haat reference-এর সত্যিকারের run থেকে।

  1. বাস্তবায়ন — নিজের মান দিয়ে নিজেকে বদলানো: অংশ ৪-এর pass tries = tries + 1-এ চুপ থাকে। Resolver-কে বাড়িয়ে SelfReadAware লিখুন, যাতে একটি assignment-এর ডান পাশে সেই একই variable-এর পড়া “পড়া” হিসেবে না গোনা হয়। cart.haat-এ কী আসবে? আর এই নিয়ম কি কখনো ভুল warning দিতে পারে?

    প্রতিটি statement-এর আগে refs-এর দৈর্ঘ্য মনে রাখুন; statement একটি Assign হলে তার নিজের binding-এর Var-পড়াগুলো সরিয়ে দিন:

    class SelfReadAware(Resolver):    # x = x + 1-এর ডান পাশের x-কে পড়া ধরে না
        def stmt(self, s):
            before = len(self.refs); super().stmt(s)
            if isinstance(s, Assign):
                mine = self.uses.get(id(s))
                self.refs[before:] = [(n, b) for n, b in self.refs[before:]
                                      if not (isinstance(n, Var) and b is mine)]

    ল্যাবের সত্যিকারের run, unused() এই resolver দিয়ে:

    3:9: warning: unused variable 'vat'
    10:9: warning: variable 'note' is assigned but never read
    12:9: warning: variable 'tries' is assigned but never read

    count চুপ থাকে, কারণ লুপের শর্তে (6:11) সেটি সত্যিই পড়া হয়। একটি বাড়তি পরীক্ষা: var total = 0; … while i < n { total = total + i; … } return 0;-এ ঠিকই 2:9: warning: variable 'total' is assigned but never read আসে। ভুল warning কি সম্ভব? নিয়মটি দাবি করে “এই variable-এর মান কখনো বাইরে যায় না”; ডান পাশের পড়া শুধু আবার একই variable-এ ফেরে, তাই দাবিটি সত্য। তবে ডান পাশে একটি function call থাকলে (tries = log(tries);) মান সেই function-এ যায়, তাই সতর্ক সংস্করণ শুধু call-হীন ডান পাশে নিয়মটি খাটাবে; Clang-ও শুধু ++ আর compound assignment-এ খাটায় (অংশ ৭)।

  2. ভুল খুঁজুন — loop নিশ্চয়ই চলবে: একজন DA.stmt-এর While শাখা “সরল” করলেন: return self.block(s.body.stmts, A), অর্থাৎ loop-এর পরের set = body-র শেষের set. fee.haat-এ কোন error হারিয়ে যায়? এটি কি sound? আর আরেকজন meet-এ ছেদের বদলে union লিখলে কী হয়?

    বাগওয়ালা সংস্করণ ল্যাবে চালালে শুধু 9:20 আসে; repeat_fee-এর 25:12 হারিয়ে যায়। কারণ body শূন্যবার চলতে পারে: repeat_fee(0)-এ fee কখনো মান পায় না, অথচ return fee; পড়ে। তাই এটি আর sound নয়। সংখ্যায়: অংশ ৮-এর একই ২০,০০০ program-এ বাগওয়ালা check ৫,৮৫৭টি program গ্রহণ করেছে, যার ৩৪টি চলার সময় মান-না-বসা variable পড়েছে; সঠিক check-এ এই সংখ্যা শূন্য।

    Union-এর বাগ (a | b) charge-কেও ছেড়ে দেয় (ল্যাবের run-এ শুধু 25:12 থাকে, 9:20 হারায়): এক শাখায় মান বসলেই “নিশ্চিত” ধরা হয়, যা “কোনো পথে” প্রশ্নের উত্তর, “প্রতিটি পথে”-র নয়। Random পরীক্ষায় এটি ৫,৭০৫টি গ্রহণ করে, যার ৫টি চলার সময় মান-না-বসা পড়েছে। লক্ষ করুন, union-এর বাগ random পরীক্ষায় খুব কম ধরা পড়েছে (৫টি), কারণ ভুল পথটি চলতে হয়, আর ছয়টি ইনপুট সব পথ চালায় না। তাই charge-এর মতো হাতে লেখা test-ও লাগে।

  3. আউটপুট বলুন: নিচের ফাইলে (ক) reference-এর check আর run কী দেবে, (খ) পাতার unreachable pass কী বলবে, (গ) unused pass (parameter বন্ধ) কী বলবে? extra নিয়ে আলাদা করে ভাবুন।
    fn ship(w: Int) -> Int {
        let base = 60;
        var extra = 0;
        if w > 5 {
            return base + w * 10;
        } else {
            return base;
        }
        extra = 20;
        return extra;
    }
    let first = ship(2);
    print(ship(7));

    সব সত্যিকারের run থেকে:

    (ক) check: ok          run: 130
    (খ) 9:5: warning: unreachable statement
    (গ) 12:5: warning: unused variable 'first'

    (ক) Body-তে return আছে আর if-এর দুই শাখাই return করে, তাই decision 21 সন্তুষ্ট; ship(7) = 60 + 70 = 130. (খ) if শেষ হয় না, তাই 9:5-এর extra = 20; মৃত; তার পরের return extra;-এ আলাদা warning নেই। (গ) first কখনো পড়া হয় না। extra-এর কোনো warning নেই, কারণ 10:12-এ সেটি পড়া হয়, যদিও সেই পড়া মৃত কোডে! দুটি pass আলাদাভাবে চলে বলে এই ফাঁক। একটি উন্নত সংস্করণ মৃত কোডের পড়াকে গুনত না; তখন extra-ও “never read”, আর বাস্তব compiler-এ এমন pass-গুলোর ক্রম আর মেলবন্ধন এই কারণেই গুরুত্বপূর্ণ।

  4. প্রমাণ — reach আর always_returns: দেখান যে যেকোনো statement তালিকা L-এর জন্য, reference-এর always_returns(L) সত্য হলে পাতার reach(L) false দেয় (L শেষ হয় না)। আর উল্টোটি কোথায় ভাঙে?

    প্রমাণের রূপরেখা (L-এর গঠনের ওপর induction; ভেতরের তালিকা আগে):

    1. দাবি: always_returns(L) সত্য মানে L-এ এমন একটি statement s আছে যা (ক) Return, বা (খ) এমন Block যার তালিকা always_returns, বা (গ) else-সহ if যার দুই শাখাই always_returns.
    2. প্রতিটি ক্ষেত্রে completes(s) = false: (ক) Return-এর জন্য সরাসরি false. (খ) Induction অনুযায়ী ভেতরের reach false. (গ) দুই শাখার reach false (induction; else if হলে ভেতরের If-এর ক্ষেত্রেও একই যুক্তি), তাই completes(else) or t = false.
    3. তালিকা: reach L হাঁটে। s-এর আগে কোনো statement শেষ না হলে তালিকা সেখানেই false ফেরত দেয়। নাহলে s-এ পৌঁছায়, live = false হয়, আর এরপর তালিকা শেষ হোক বা পরের statement-এ warning দিয়ে থামুক, ফল false. ∎
    4. উল্টোটি: reach আরও দুটি জায়গায় false দেয় যেখানে always_returns দেয় না: while true (decision 21-এ while কখনো গোনা হয় না), আর এর ফলে এমন if/Block যার ভেতরে while true. অংশ ৮-এর T1 ঠিক এটিই মেপেছে: ১,০৩,২৪৫টি তালিকার ২,৭৯৭টি অমিলের প্রতিটিতে while true, অন্য কোনো অমিল নেই, আর প্রথম দিকের অমিল (always_returns সত্য, reach সত্য) শূন্য।

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

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

ক্রমHaat-এর বর্ধিত রূপে var fee: Int; if c { fee = 60; } else { fee = 120; } return total + fee;-এর definite assignment হিসাবের ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. var fee: Int; → fee tracked, A = { }
  2. শর্ত c-এর ভেতরের নামগুলো A = { } দিয়ে পরীক্ষা
  3. Then-শাখা: fee = 60; → {fee}
  4. Else-শাখা: fee = 120; → {fee}
  5. মিলন: {fee} ⊓ {fee} = {fee}
  6. return total + fee;: fee ∈ A, কোনো error নেই

Haat-এর বর্ধিত রূপ (initializer ছাড়া var): fn f(n: Int) -> Int { var x: Int; while n > 0 { x = 1; return x; } return x; }. Definite assignment-এর নিয়মে (শাখার মিলনে ছেদ, while-এর পরে শুধু ঢোকার আগের set) কী হবে?

  • কোনো error নেই, কারণ loop-এর ভেতরে x মান পায়
  • শুধু শেষের return x;-এ error
  • শুধু loop-এর ভেতরের return x;-এ error
  • দুটি return x;-এই error

OpenJDK 21-এর javac-এ একটি method-এ if (false) { System.out.println("a"); } আর while (false) { System.out.println("b"); } দুটি লাইন। কী হয়?

  • দুটিই compile হয়, কোনো বার্তা নেই
  • দুটিই unreachable statement error
  • শুধু while (false)-এর লাইনে error: unreachable statement
  • দুটিতেই শুধু warning, program চলে

Haat v1 reference (python -B haat.py check): fn wait_stock(n: Int) -> Int { var k = n; while true { if k > 0 { return k; } k = k + 1; } } (function-এর নাম লাইন ১, column ৪-এ)। ফল কী?

  • 1:4: error: missing return: not every path of function 'wait_stock' returns Int
  • ok, কারণ while true থেকে শুধু return দিয়েই বেরোনো যায়
  • warning: unreachable statement
  • cannot assign to 'k'

একটি definite assignment check কখনো এমন program গ্রহণ করে না যা চলার সময় মান-না-বসা variable পড়তে পারে, কিন্তু কিছু program আটকায় যারা কখনো তা পড়ে না। Static analysis-এর ভাষায় check-টি কী?

  • Complete, কিন্তু sound নয়
  • Sound আর complete দুটিই
  • কোনোটিই নয়
  • Sound, কিন্তু complete নয় (conservative)

clang 22 দিয়ে শুধু -Wall flag দিয়ে একটি C ফাইল compile করা হলো, যাতে আছে: একটি unused local variable, return-এর পরে একটি statement, একটি enum switch যেখানে একটি মান বাদ, আর 7 / 0. কোনটির warning আসবে না?

  • Unused local variable
  • return-এর পরের statement
  • Enum switch-এ বাদ পড়া মান
  • 7 / 0

Type: enum Zone { Dhaka, Outside }, enum Ship { Pickup, Home(Zone, Bool) }. একটি match-এর arm: Pickup, Home(Dhaka, _), Home(_, true). Usefulness algorithm কোন মানকে না-ধরা উদাহরণ হিসেবে দেবে?

  • Pickup
  • Home(Dhaka, false)
  • Home(Outside, false)
  • Home(Outside, true)

শব্দকোষ

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

মনে রাখুন

  1. Type-এর বাইরে চার check: unreachable code, unused variable, definite assignment, exhaustiveness; সঙ্গে constant-expression check. ভাষাভেদে error, warning বা কিছুই না।
  2. নিখুঁত নয়, ইচ্ছা করে: Rice-এর theorem-এর কারণে প্রতিটি check একটি দিক বেছে নেয়; error-এর নিয়ম সাধারণত sound আর specification-এ লেখা, warning-এর দাবি সত্য হতে হয়।
  3. Reachability: “শেষ হয় কি?” return না, if/else যেকোনো শাখা হলে, while true না; Haat-এর decision 21 আরও কড়া।
  4. Definite assignment: set A সামনে বয়ে নেওয়া, assignment-এ ∪, মিলনে ছেদ, return-এ ⊤, loop-এর পরে ঢোকার আগের A.
  5. Exhaustiveness: usefulness একই প্রশ্নে redundancy আর অসম্পূর্ণতা দুটিই ধরে, সঙ্গে একটি না-ধরা উদাহরণ; guard আর wildcard ভেবেচিন্তে।

পরের পর্বে: পর্ব ৫৫-এ (Desugaring আর lowering) বড় ভাষাকে ছোট core-এ নামানো: else if থেকে nested if, বর্ধিত রূপের for আর += থেকে সাধারণ Haat, আর একটি প্রশ্ন যা এই পর্বের check-গুলোর সঙ্গেও জড়িত: error আর warning কোন কোডের ওপর দেবেন, লেখা কোডের না নামানো কোডের?

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

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