এই পর্বে যা শিখবেন
- একটি formatter-এর সঠিকতা তিনটি property দিয়ে পরীক্ষা করা, আর বোঝা কেন শুধু idempotence যথেষ্ট নয়
- Linter-এর নিয়মকে AST-এর ওপর একটি pass হিসেবে লেখা, আর Python
astও Clang-Wall-এর সত্যিকারের সতর্কবার্তা পড়া - Language Server Protocol-এর JSON-RPC বার্তা, জীবনচক্র আর position encoding ব্যাখ্যা করা
- Haat-এর জন্য একটি ছোট language server বানানো: diagnostic, hover আর go-to-definition, যার error
haat.py check-এর সমান - Incremental compilation, red–green tree আর query-based compiler-এর মূল কৌশল ধরা, আর debugger, REPL ও build system-কে একই ছবিতে বসানো
১ · Compiler-এর বাইরে — যে tool নিয়ে প্রতিদিন কাজ
এই কোর্সে আপনি Haat-এর পুরো front end বানিয়েছেন: পর্ব ৪৬-এর lexer, পর্ব ৪৭ আর ৪৮-এর parser, পর্ব ৪৯-এর AST আর pretty printer, পর্ব ৫১-এর resolver আর পর্ব ৫২-এর type checker. Compiler এগুলো একবার চালায়, error ছাপে, তারপর থামে। কিন্তু একজন প্রোগ্রামার দিনের বেশির ভাগ সময় compiler চালান না; তিনি editor-এ লেখেন। লেখার সময়েই লাল ঢেউ-দাগ (squiggle), নামের ওপর মাউস রাখলে type, এক ক্লিকে ঘোষণায় যাওয়া, সংরক্ষণের সময় কোড গোছানো: এগুলো আসে language tooling থেকে।
উপমা — বাজারঘরের হিসাবরক্ষক: বছরের শেষে একজন নিরীক্ষক (auditor) পুরো খাতা একবারে পড়ে ভুলের তালিকা দেন: এটি compiler. সারা বছর পাশে বসা একজন হিসাবরক্ষক প্রতিটি নতুন লাইন লেখার সঙ্গে সঙ্গে বলেন “এই অঙ্কে ভুল”, “এই গ্রাহকের নাম আগে কোথায় এসেছে”, আর পুরোনো পাতা আবার পড়েন না, শুধু বদলানো পাতাটুকু দেখেন: এটি language server. দুজনের জ্ঞান একই হিসাবের নিয়ম; তফাত কখন আর কতটুকু পড়েন।
এই পর্বের মূল কথা: tool-গুলো নতুন কোনো তত্ত্ব নয়, বরং পুরোনো data structure-এর নতুন ব্যবহার। Formatter মানে AST থেকে আবার লেখা। Linter মানে AST-এর ওপর আরও কিছু নিয়ম। Hover মানে symbol table-এ একটি নামের type খোঁজা। Go-to-definition মানে name resolution-এর ফল উল্টো দিক থেকে পড়া। নতুন যা আসে, তা প্রকৌশলের প্রশ্ন: editor আর বিশ্লেষকের মাঝে কোন ভাষায় কথা হবে, প্রতিটি অক্ষর বদলালে কতটুকু কাজ আবার করতে হবে, আর ভাঙা কোডেও কীভাবে কাজ চালানো যায়। নিচের ছবিতে পুরো ব্যবস্থা।
ছবি ৮০.১ — Editor, LSP আর Haat-এর language server
ওপরে editor (client), মাঝে JSON-RPC বার্তা, নিচে server-এর ভেতরে পর্ব ৪৬–৫২-এর front end. সবচেয়ে নিচে কেন একটি সাধারণ protocol লাভজনক।
২ · Formatter — AST থেকে আবার লেখা, আর idempotence
পর্ব ৪৯-এ আপনি pretty-printer লিখেছেন: AST থেকে সবচেয়ে কম বন্ধনী দিয়ে canonical (একমাত্র স্বীকৃত রূপের) Haat লেখা। Formatter সেই printer-এর সামনে একটি parser বসানো: fmt(s) = pretty(parse(s)). Reference-এর fmt ঠিক এটিই। একটি অগোছালো ফাইলে সত্যিকারের run (reference বাস্তবায়ন, CPython 3.14.4):
~/haat $ cat messy.haat
// বাজারঘর: ছাড়ের নিয়ম, অগোছালো
fn discount(total:Int,vip:Bool)->Int{if ((total>=1000))==vip{return (total-200)*9/10;}
return total-(total-total/20);}
print( discount(1500,true) );print(-(3-10)%4);
~/haat $ python haat.py fmt messy.haat > once.haat
~/haat $ python haat.py fmt once.haat > twice.haat
~/haat $ cat once.haat
fn discount(total: Int, vip: Bool) -> Int {
if total >= 1000 == vip {
return (total - 200) * 9 / 10;
}
return total - (total - total / 20);
}
print(discount(1500, true));
print(-(3 - 10) % 4);
~/haat $ cmp once.haat twice.haat && echo same
same
~/haat $ python haat.py run messy.haat; python haat.py run once.haat
1170
3
1170
3
তিনটি জিনিস লক্ষ করুন। (১) ((total>=1000))==vip-এর দুই জোড়া বন্ধনী গেছে, কারণ >= আর == ভিন্ন স্তরের, তাই মেশানো বৈধ (spec সিদ্ধান্ত ১০); কিন্তু (total-200)-এর বন্ধনী আছে, কারণ সেটি ছাড়া অর্থ বদলাত। (২) দ্বিতীয়বার চালালে কিছুই বদলায়নি। (৩) Comment হারিয়ে গেছে: AST-এ comment নেই। বাস্তবের formatter-কে তাই comment আর ফাঁকা লাইন (একসাথে বলে trivia) গাছে রাখতে হয়, যাকে পর্ব ৪৯-এ lossless syntax tree বলেছি। Haat-এর fmt একটি শিক্ষার tool, সত্যিকারের কাজে comment মুছে ফেলা চলবে না।
s যেকোনো বৈধ Haat লেখা, fmt(s) = pretty(parse(s)), আর ≅ মানে অবস্থান বাদ দিয়ে একই AST. একটি সঠিক formatter: (F1) idempotent: fmt(fmt(s)) = fmt(s). (F2) layout-এ অন্ধ: s আর s′-এর token একই হলে (শুধু ফাঁকা জায়গা, লাইন-ভাঙা আর comment আলাদা) fmt(s) = fmt(s′). (F3) অর্থ অটুট: parse(fmt(s)) ≅ parse(s).
F3-ই আসল দাবি, আর পর্ব ৪৯-এর উপপাদ্য ৪৯.১ (parse(fmt(e)) ≅ e) সেটিই প্রমাণ করেছে। অনুশীলন ২-এ দেখবেন, F3 থেকে F1 আসে, কিন্তু উল্টোটা আসে না। নিচের ব্লক তিনটি শর্তই গুনে দেখে। Printer হলো reference-এর ast_print.py হুবহু (শুধু import লাইন বদলে haat_front থেকে নেওয়া)। পরীক্ষার ইনপুট চারটি ফাইলের (bazar.haat, cart.haat, rules.haat, shop.haat) এলোমেলো “অগোছালো” রূপ: একই token, মাঝে এলোমেলো space, newline আর comment.
import random
import haat_fmt # the reference ast_print.py: pretty() and sexpr()
from haat_front import tokenize, Parser, Program
def parse(src): return Program(Parser(tokenize(src)).statements_until("EOF"))
def fmt(src): return haat_fmt.pretty(parse(src)) # what `haat.py fmt` prints
def tree(src): return haat_fmt.sexpr(parse(src)) # what `haat.py ast` prints
def noise(src, r): # the same tokens with random spaces, newlines, comments
gaps = [" ", " ", "\n", "\n ", " // নোট\n", "\t"]
return "".join(t.text + r.choice(gaps) for t in tokenize(src)[:-1])
def test(n=400, seed=80):
r, c = random.Random(seed), {"idempotent": 0, "layout-proof": 0, "same tree": 0}
for _ in range(n):
orig = open(r.choice(["bazar.haat", "cart.haat", "rules.haat", "shop.haat"]),
encoding="utf-8").read()
messy = noise(orig, r); once = fmt(messy)
c["idempotent"] += fmt(once) == once # fmt(fmt(x)) == fmt(x)
c["layout-proof"] += once == fmt(orig) # spaces and comments do not matter
c["same tree"] += tree(once) == tree(orig) # parse(fmt(x)) is the same tree
print(f"{n} messy programs:", c)
print(fmt('let d=-(a+b)*c ;if d>0{print( "ছাড়" );}'), end="")
test()
good = haat_fmt.wrap # plant a bug: the printer never writes parentheses
haat_fmt.wrap = lambda e, paren, ind: haat_fmt.expr(e, ind)
print(fmt("let d = -(a + b) * c;"), end="")
test()
haat_fmt.wrap = goodআসল আউটপুট (ব্রাউজারের Python):
let d = -(a + b) * c;
if d > 0 {
print("ছাড়");
}
400 messy programs: {'idempotent': 400, 'layout-proof': 400, 'same tree': 400}
let d = -a + b * c;
400 messy programs: {'idempotent': 400, 'layout-proof': 400, 'same tree': 311}
সঠিক printer-এ ৪০০টি অগোছালো program-এর প্রতিটিতে তিন শর্তই পূরণ। তারপর একটি bug বসানো হলো: wrap আর কখনো বন্ধনী লেখে না। -(a + b) * c হয়ে গেল -a + b * c, সম্পূর্ণ অন্য হিসাব। অথচ F1 আর F2 এখনো ৪০০-তে ৪০০: ভুল রূপটিও স্থির, আর layout-এ অন্ধ। শুধু F3 ধরেছে, ৮৯টি program-এ AST বদলেছে (প্রধানত বন্ধনীওয়ালা rules.haat ফাইলে)। শিক্ষা: “দুবার চালালে কিছু বদলায় না” পরীক্ষা সহজ, কিন্তু সেটি সঠিকতার প্রমাণ নয়। ল্যাবে এই পাতার fmt-কে reference-এর fmt-এর সঙ্গে মিলিয়েছি (অন্য seed-এ ২০০০টি অগোছালো program, ২০০০টিতেই অক্ষরে অক্ষরে এক), আর reference-এর ১৩টি উদাহরণ-ফাইলের যে ১২টি parse হয়, তার ১২টিতেই fmt দুবার চালালে একই ফল।
বাস্তবের formatter আরও একটি কঠিন কাজ করে: লাইন ভাঙা। একটি লম্বা call এক লাইনে ধরবে, না প্রতিটি argument আলাদা লাইনে যাবে? Derek Oppen-এর ১৯৮০ সালের pretty-printing algorithm আর Philip Wadler-এর “A prettier printer” (১৯৯০-এর দশকের শেষে) এই সিদ্ধান্তকে গ্রুপ আর “এখানে ভাঙা যায়” চিহ্নের ভাষায় লেখে; Prettier-এর মতো tool এই ধারার বলে তাদের নথিতে উল্লেখ আছে। Go-র gofmt ভাষার শুরু থেকে (২০০৯) আছে, JavaScript-এর Prettier আর Python-এর Black এসেছে ২০১৭–২০১৮ সালের দিকে। এদের মিল একটি নকশা-সিদ্ধান্তে: বিকল্প প্রায় নেই, তাই দলের মধ্যে ধাঁচ নিয়ে তর্কও নেই। ব্যবহারের দিক (Prettier, ESLint) আছে JavaScript কোর্সের পর্ব ৪৬-এ আর দলের কোডের ধাঁচ Software Engineering কোর্সের পর্ব ৪১-এ.
৩ · Linter — নিয়ম মানে AST-এর ওপর একটি pass
Compiler-এর error বলে “এই program ভাষার নিয়ম ভাঙে”। Linter-এর সতর্কবার্তা বলে “এই program বৈধ, কিন্তু সন্দেহজনক”। পর্ব ৫৪-এ definite assignment আর unreachable code-এর মতো check দেখেছেন; linter একই ধাঁচের pass, শুধু তার রায় পরামর্শ। প্রতিটি নিয়ম একটি ছোট visitor: গাছ হাঁটে, একটি ধাঁচ খোঁজে, অবস্থানসহ বার্তা দেয়। নিচে Python-এর নিজের ast module দিয়ে লেখা তিন নিয়মের একটি linter, আর একটি সন্দেহজনক ফাইলে তার সত্যিকারের run (CPython 3.14.4):
import ast, sys
class Lint(ast.NodeVisitor): # every rule is one visit_ method on the AST
def __init__(self, path): self.path, self.found = path, []
def report(self, node, code, msg):
self.found.append(f"{self.path}:{node.lineno}:{node.col_offset + 1}: {code} {msg}")
def visit_FunctionDef(self, node):
for d in node.args.defaults: # L1: mutable default argument
if isinstance(d, (ast.List, ast.Dict, ast.Set)):
self.report(d, "L1", f"mutable default argument in '{node.name}'")
assigned = {t.id: t for s in ast.walk(node) if isinstance(s, ast.Assign)
for t in s.targets if isinstance(t, ast.Name)}
used = {n.id for n in ast.walk(node) if isinstance(n, ast.Name) and isinstance(n.ctx, ast.Load)}
for name, t in assigned.items(): # L2: local assigned but never read
if name not in used: self.report(t, "L2", f"local variable '{name}' is assigned but never used")
self.generic_visit(node)
def visit_Compare(self, node): # L3: == None instead of `is None`
for op, right in zip(node.ops, node.comparators):
if isinstance(op, (ast.Eq, ast.NotEq)) and isinstance(right, ast.Constant) and right.value is None:
self.report(node, "L3", "comparison to None should use 'is' / 'is not'")
self.generic_visit(node)
for path in sys.argv[1:]:
lint = Lint(path); lint.visit(ast.parse(open(path, encoding="utf-8").read(), path))
print(*lint.found, sep="\n")~/lint $ cat cart.py
# বাজারঘর: ঝুড়ি (Python)
def add_item(item, cart=[]):
cart.append(item)
return cart
def total(prices, coupon=None):
discount = 0
subtotal = sum(prices)
if coupon == None:
return subtotal
return subtotal - subtotal // 20
~/lint $ python lint.py cart.py
cart.py:2:25: L1 mutable default argument in 'add_item'
cart.py:7:5: L2 local variable 'discount' is assigned but never used
cart.py:9:8: L3 comparison to None should use 'is' / 'is not'
L1 সবচেয়ে বিখ্যাত Python ফাঁদ: default মান একবারই তৈরি হয়, তাই প্রতিটি ডাক একই list ভাগ করে। L2 একটি ছোট dataflow প্রশ্ন, তবে খুব সরল রূপে: “পুরো function-এ এই নাম কোথাও পড়া হয়েছে কি?” L3 ধাঁচের প্রশ্ন। তিনটিই static analysis: কোড না চালিয়ে। Ruff, Pylint বা ESLint-এর মতো বাস্তব linter-এ শত শত নিয়ম, কিন্তু প্রতিটির কাঠামো এই রকম।
Compiler নিজেও linter-এর কাজ করে। একটি সন্দেহজনক C ফাইলে Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8-এর সত্যিকারের run (-fsyntax-only মানে শুধু parse আর semantic check, কোনো object file নয়; header-এর ঝামেলা এড়াতে printf হাতে ঘোষণা করা):
~/lint $ python -m ziglang clang -fsyntax-only -Wall bazar.c
bazar.c:6:11: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
6 | if (p = 1000) { return p - p / 10; }
| ~~^~~~~~
bazar.c:6:11: note: place parentheses around the assignment to silence this warning
6 | if (p = 1000) { return p - p / 10; }
| ^
| ( )
bazar.c:6:11: note: use '==' to turn this assignment into an equality comparison
6 | if (p = 1000) { return p - p / 10; }
| ^
| ==
bazar.c:5:9: warning: unused variable 'unused' [-Wunused-variable]
5 | int unused = 0;
| ^~~~~~
bazar.c:11:20: warning: format specifies type 'int' but the argument has type 'long' [-Wformat]
11 | printf("%d\n", total);
| ~~ ^~~~~
| %ld
3 warnings generated.
~/lint $ python -m ziglang clang -fsyntax-only -Wall -fdiagnostics-parseable-fixits bazar.c 2>&1 | grep fix-it
fix-it:"bazar.c":{6:9-6:9}:"("
fix-it:"bazar.c":{6:17-6:17}:")"
fix-it:"bazar.c":{6:11-6:12}:"=="
fix-it:"bazar.c":{11:13-11:15}:"%ld"
দুটি জিনিস tool-এর দিক থেকে গুরুত্বপূর্ণ। এক, প্রতিটি বার্তার সঙ্গে একটি range (~~^~~~~~): শুধু একটি বিন্দু নয়, পুরো সন্দেহজনক expression. দুই, fix-it hint: “এই range-এ এই লেখা বসান”। দ্বিতীয় command সেগুলো যন্ত্রে পড়ার রূপে দেয়, আর if (p = 1000)-এর জন্য দুটি বিকল্প প্রস্তাব আছে: বন্ধনী (ইচ্ছাকৃত assignment) বা ==. Editor-এ এগুলোই “quick fix” বাতি হয়ে আসে, LSP-তে যার নাম code action. Haat-এর reference error-এ শুধু বিন্দু (line:col) আছে; অংশ ৫-এর server তাই token-এর দৈর্ঘ্য দিয়ে range বানাবে।
সীমা: L2-এর মতো নিয়ম কখনো ভুল সতর্ক করে (false positive), কখনো আসল সমস্যা ছেড়ে দেয় (false negative), দুটিই ঘটে। এটি অলসতা নয়, গণিত: “এই মান কি কখনো ব্যবহার হবে?” ধরনের অর্থগত প্রশ্ন সাধারণভাবে undecidable (গণনার তত্ত্বের পর্ব ৫৩, Rice-এর উপপাদ্য; বিশ্লেষণের সীমা নিয়ে পর্ব ৭৮)। তাই linter বেছে নেয় কোন দিকে ভুল করবে, আর ব্যবহারকারীকে চুপ করানোর উপায় দেয়। Go ভাষা আরও এক ধাপ গেছে: অব্যবহৃত import আর অব্যবহৃত local variable সেখানে compile error, শুধু সতর্কবার্তা নয়।
৪ · Language Server Protocol — editor আর বিশ্লেষকের চুক্তি
LSP-র আগে প্রতিটি editor প্রতিটি ভাষার জন্য নিজের plugin লিখত, প্রায়ই নিজের অসম্পূর্ণ parser দিয়ে। পাঁচটি editor আর আটটি ভাষা মানে চল্লিশটি আলাদা বাস্তবায়ন, প্রতিটির নিজের bug. Microsoft ২০১৬ সালে (Red Hat আর Codenvy-র সঙ্গে, বলে সাধারণত উল্লেখ করা হয়) Visual Studio Code-এর ভেতরের ব্যবস্থা থেকে Language Server Protocol প্রকাশ করে। ধারণাটি সরল: ভাষার সব বুদ্ধি থাকবে একটি আলাদা process-এ, যাকে বলে language server, আর editor তার সঙ্গে একটি নির্দিষ্ট বার্তার ভাষায় কথা বলবে। এই পর্বের বার্তার আকার নেওয়া হয়েছে LSP specification-এর 3.18 সংস্করণের পাতা থেকে (২০২৬-এর নভেম্বরে পাতাটি 3.18-কে “current” আর 3.19-কে “upcoming” বলে)।
প্রতিটি বার্তা দুই অংশ: header আর content. Header-এ Content-Length: N (content-এর দৈর্ঘ্য, byte-এ), তারপর \r\n\r\n; content একটি JSON-RPC 2.0 object, "jsonrpc": "2.0" সহ। (১) Request: id, method, params. (২) তার ঠিক একটি response আসবে একই id আর result (বা error) নিয়ে। (৩) Notification: id নেই, উত্তরও নেই। বার্তা দুই দিকেই যায়: textDocument/publishDiagnostics server থেকে editor-এ পাঠানো notification.
একটি অধিবেশনের (session) ক্রম: editor পাঠায় initialize request, নিজের সামর্থ্য (capabilities) জানিয়ে; server উত্তরে জানায় সে কী পারে (hover, definition, কোন sync পদ্ধতি)। তারপর editor-এর initialized notification. ফাইল খুললে textDocument/didOpen (পুরো লেখা সহ), প্রতিটি বদলে textDocument/didChange. Server নিজের ইচ্ছায়, যখন বিশ্লেষণ শেষ, publishDiagnostics পাঠায়। শেষে shutdown request আর exit notification. Sync-এর দুই রূপ: textDocumentSync: 1 (Full) মানে প্রতিটি বদলে পুরো লেখা আসে, 2 (Incremental) মানে শুধু বদলানো range আর নতুন লেখা। অংশ ৫-এর server Full ব্যবহার করে, কারণ সরল।
অবস্থানের ফাঁদ। LSP-র Position হলো {line, character}, দুটিই ০ থেকে গোনা। আর character কিসে মাপা? Specification অনুযায়ী server কিছু না বললে ডিফল্ট "utf-16": UTF-16 code unit. কারণ ঐতিহাসিক: VS Code JavaScript-এ লেখা, আর JavaScript-এর string UTF-16-এ। 3.17 থেকে client আর server positionEncoding নিয়ে আলোচনা করতে পারে ("utf-8", "utf-16", "utf-32"), তবে utf-16 সবাইকে সমর্থন করতে হয়। Haat-এর column ১ থেকে আর code point ধরে (spec সিদ্ধান্ত ১)। পর্ব ২১-এ দেখেছেন, বাংলা অক্ষর UTF-16-এ একটি unit, কিন্তু 🛒-এর মতো emoji BMP-র বাইরে, তাই দুটি unit (একটি surrogate pair হিসেবে)।
print("🛒 মোট: " + total);-এ total-এর শুরু | মান |
|---|---|
Haat check (১ থেকে, code point) | column 19 |
| LSP, utf-16 (০ থেকে, UTF-16 unit) | character 19 (18 code point + emoji-র বাড়তি 1) |
| LSP, utf-32 (০ থেকে, code point) | character 18 |
| LSP, utf-8 (০ থেকে, byte) | character 27 |
শেষ সারির 27: print(-এর ছয়টি, দুটি ", চারটি space, : আর + মিলে ১৪টি ASCII byte, ঝুড়ির emoji চার byte, আর মোট-এর তিনটি বাংলা code point (ম, ো, ট) প্রতিটি তিন byte করে, অর্থাৎ ৯; সব মিলে ২৭। নিচের stepper একটি পূর্ণ অধিবেশন দেখায়; প্রতিটি বার্তা আর Content-Length অংশ ৫-এর সত্যিকারের run থেকে নেওয়া।
1→ initialize id 12← result id 13→ initialized (no id)4→ didOpen (no id)5← publishDiagnostics6→ didChange (no id)7← publishDiagnostics
| ধরন | |
| Content-Length | |
| মূল অংশ |
- Editor-এর প্রথম request.
initialize,id1; params-এprocessId,rootUriআর editor-এর capabilities (এখানে খালি)। মোট ১১৯ byte. - Server-এর response. একই
id1. সে জানায়: অবস্থান utf-16-এ, sync Full (1), hover আর definition পারে, নামhaat-mini-ls. - initialized. Notification:
idনেই, তাই server কোনো উত্তর দেয় না। এর পরেই আসল কাজ শুরু। - ফাইল খোলা।
didOpen-এ uri,languageId“haat”, version 1 আর পুরো লেখা: ৫০৫ byte, কারণ বাংলা অক্ষর আর 🛒 UTF-8-এ কয়েক byte করে। - Server-এর বিজ্ঞপ্তি। কেউ চায়নি, তবু server নিজে
publishDiagnosticsপাঠায়: দুটি type mismatch, প্রতিটি ০ থেকে গোনা range সহ। Editor সেখানে লাল দাগ আঁকে। - লেখা বদল। ভুল দুটি সারানো হলো; Full sync, তাই
didChange-এ version 2 আর পুরো নতুন লেখা, মোট ৪৯৪ byte. - আবার বিজ্ঞপ্তি। এবার
diagnostics: []. খালি তালিকা পাঠানো জরুরি: এটিই editor-কে আগের দাগ মুছতে বলে।
৫ · Haat-এর জন্য একটি ছোট language server
এবার নিজে বানাই। ব্লকগুলো দুটি সহায়ক module import করে, দুটিই আগের পর্ব থেকে অপরিবর্তিত কপি: haat_front.py (পর্ব ৫২-এর পাতার সহায়ক module, যাতে আছে পর্ব ৪৬–৫১-এর lexer, parser আর resolver-এর সংক্ষিপ্ত রূপ) আর haat_check.py (পর্ব ৫২-এর তিনটি type checker ব্লক, শুধু শেষের পরীক্ষার লাইনগুলো বাদ)। প্রথম ব্লক server-এর ভেতরের চারটি কাজ: বিশ্লেষণ, অবস্থান রূপান্তর, গাছ হাঁটা, আর কার্সরের নিচের নামের binding খোঁজা। ফাইল cart.haat-এ ইচ্ছাকৃত দুটি ভুল:
// বাজারঘর: ঝুড়ির হিসাব
fn price(qty: Int, unit: Int) -> Int {
let p = qty * unit;
if p >= 1000 { return p - p / 10; }
return p;
}
var total = price(2, 520);
{
let total = price(1, 60) + 1;
print(total);
}
print("🛒 মোট: " + total);
total = total + "60";from haat_front import * # পর্ব ৪৬–৫১: lexer, parser, AST, resolver (Binding)
from haat_check import TypeChecker # পর্ব ৫২: the type checker, unchanged
def analyze(text): # the phases of `haat.py check`, keeping the trees
program = res = None
try:
program = Program(Parser(tokenize(text)).statements_until("EOF"))
res = Resolver().program(program); TypeChecker(res).program(program); errs = []
except HaatError as e: errs = [e] # lexer or parser: the first error only
except HaatErrors as e: errs = e.errors # resolver or checker: all, sorted
return errs, program, res
def to_lsp(text, line, col): # Haat 1-based code points -> LSP 0-based UTF-16 units
before = text.split("\n")[line - 1][:col - 1]
return {"line": line - 1, "character": len(before.encode("utf-16-le")) // 2}
def from_lsp(text, p): # LSP position -> Haat (line, col)
row, units, col = text.split("\n")[p["line"]], 0, 1
while units < p["character"]: units += len(row[col - 1].encode("utf-16-le")) // 2; col += 1
return p["line"] + 1, col
def width(text, line, col): # length of the token that starts there, else 1
try: return next(len(t.text) for t in tokenize(text) if (t.line, t.col) == (line, col)) or 1
except (HaatError, StopIteration): return 1
def span(text, line, col, n): # an LSP Range covering n code points
return {"start": to_lsp(text, line, col), "end": to_lsp(text, line, col + n)}
def walk(x): # every AST node, in source order
if isinstance(x, list): yield from (n for y in x for n in walk(y))
elif hasattr(x, "line"): yield x; yield from (n for v in vars(x).values() for n in walk(v))
def binding_at(program, res, line, col): # the name under the cursor -> (node, Binding)
for n in walk(program.stmts):
b = res.uses.get(id(n)) or res.decls.get(id(n))
if b and n.line == line and n.col <= col < n.col + len(b.name): return n, b
return None, None
text = open("cart.haat", encoding="utf-8").read(); errs, program, res = analyze(text)
for e in errs: print(e, "->", to_lsp(text, e.line, e.col))
for line, col in [(10, 11), (13, 9), (2, 6)]:
n, b = binding_at(program, res, line, col)
print(f"{line}:{col} -> {b.kind} {b.name}: {b.type}, declared at {b.line}:{b.col}")আসল আউটপুট (ব্রাউজারের Python):
12:19: error: type mismatch: expected Str, found Int -> {'line': 11, 'character': 19}
13:17: error: type mismatch: expected Int, found Str -> {'line': 12, 'character': 16}
10:11 -> let total: Int, declared at 9:9
13:9 -> var total: Int, declared at 7:5
2:6 -> fn price: (Int, Int) -> Int, declared at 2:4
প্রথম দুই লাইন reference-এর python haat.py check cart.haat-এর আউটপুটের সঙ্গে অক্ষরে অক্ষরে এক। রূপান্তরে লাইন ১২-তে ঝুড়ির emoji-র জন্য character 19, অর্থাৎ ১ বিয়োগ আর ১ যোগ কাটাকাটি; লাইন ১৩-তে শুধু ASCII, তাই 17 → 16. পরের তিন লাইন hover আর definition-এর কাঁচামাল: লাইন ১০-এর total ভেতরের block-এর let (9:9), লাইন ১৩-এর total বাইরের var (7:5), আর price-এর type পুরো function type. Type error থাকা সত্ত্বেও type পাওয়া যায়, কারণ checker সব type বসিয়ে শেষে error তোলে; resolver ব্যর্থ হলে res হয় None, তখন hover চুপ।
দ্বিতীয় ব্লক server নিজে: একটি handle method, যা একটি বার্তা নেয় আর পাঠানোর বার্তার তালিকা ফেরত দেয়। সঙ্গে একটি ছোট “editor”, যে অংশ ৪-এর অধিবেশন চালায়, তারপর hover আর definition চায়। আসল server এই বার্তাগুলো stdin থেকে পড়ত আর stdout-এ লিখত, প্রতিটির আগে Content-Length header দিয়ে; এখানে শুধু সেই দৈর্ঘ্য ছাপা হয়।
import json
class Server: # LSP 3.18 message shapes, full-text sync
def __init__(self): self.docs = {} # uri -> the current text of each open file
def handle(self, msg): # one JSON-RPC message in, a list of messages out
m, p = msg["method"], msg.get("params", {})
reply = lambda result: [{"jsonrpc": "2.0", "id": msg["id"], "result": result}]
if m == "initialize":
return reply({"capabilities": {"positionEncoding": "utf-16", "textDocumentSync": 1, "hoverProvider": True,
"definitionProvider": True}, "serverInfo": {"name": "haat-mini-ls"}})
if m in ("textDocument/didOpen", "textDocument/didChange"):
uri = p["textDocument"]["uri"]
text = self.docs[uri] = p["textDocument"]["text"] if "Open" in m else p["contentChanges"][-1]["text"]
diags = [{"range": span(text, e.line, e.col, width(text, e.line, e.col)), "severity": 1,
"source": "haat", "message": e.message} for e in analyze(text)[0]]
return [{"jsonrpc": "2.0", "method": "textDocument/publishDiagnostics", "params": {"uri": uri, "diagnostics": diags}}]
if m in ("textDocument/hover", "textDocument/definition"):
text = self.docs[p["textDocument"]["uri"]]; _, program, res = analyze(text)
n, b = binding_at(program, res, *from_lsp(text, p["position"])) if res else (None, None)
if b is None: return reply(None)
if m.endswith("hover"): return reply({"contents": {"kind": "markdown", "value": f"`{b.kind} {b.name}: {b.type}`"},
"range": span(text, n.line, n.col, len(b.name))})
return reply({"uri": p["textDocument"]["uri"], "range": span(text, b.line, b.col, len(b.name))})
return [] # notifications such as "initialized": no answer
uri, srv, ids = "file:///home/haat/cart.haat", Server(), iter(range(1, 99))
def send(method, **params): # the editor's side: a request has an id, a notification not
msg = {"jsonrpc": "2.0", "method": method, "params": params}
if method in ("initialize", "textDocument/hover", "textDocument/definition"): msg["id"] = next(ids)
print(f"-> {method} (Content-Length: {len(json.dumps(msg, ensure_ascii=False).encode())})")
for out in srv.handle(msg): print("<-", json.dumps(out.get("result", out.get("params")), ensure_ascii=False))
send("initialize", processId=None, rootUri=None, capabilities={}); send("initialized")
send("textDocument/didOpen", textDocument={"uri": uri, "languageId": "haat", "version": 1, "text": text})
fixed = text.replace('print("🛒 মোট: " + total);', 'print("🛒 মোট:");').replace('"60"', "60")
send("textDocument/didChange", textDocument={"uri": uri, "version": 2}, contentChanges=[{"text": fixed}])
send("textDocument/hover", textDocument={"uri": uri}, position={"line": 9, "character": 10})
send("textDocument/definition", textDocument={"uri": uri}, position={"line": 12, "character": 9})আসল আউটপুট (ব্রাউজারের Python):
-> initialize (Content-Length: 119)
<- {"capabilities": {"positionEncoding": "utf-16", "textDocumentSync": 1, "hoverProvider": true, "definitionProvider": true}, "serverInfo": {"name": "haat-mini-ls"}}
-> initialized (Content-Length: 57)
-> textDocument/didOpen (Content-Length: 505)
<- {"uri": "file:///home/haat/cart.haat", "diagnostics": [{"range": {"start": {"line": 11, "character": 19}, "end": {"line": 11, "character": 24}}, "severity": 1, "source": "haat", "message": "type mismatch: expected Str, found Int"}, {"range": {"start": {"line": 12, "character": 16}, "end": {"line": 12, "character": 20}}, "severity": 1, "source": "haat", "message": "type mismatch: expected Int, found Str"}]}
-> textDocument/didChange (Content-Length: 494)
<- {"uri": "file:///home/haat/cart.haat", "diagnostics": []}
-> textDocument/hover (Content-Length: 169)
<- {"contents": {"kind": "markdown", "value": "`let total: Int`"}, "range": {"start": {"line": 9, "character": 10}, "end": {"line": 9, "character": 15}}}
-> textDocument/definition (Content-Length: 174)
<- {"uri": "file:///home/haat/cart.haat", "range": {"start": {"line": 6, "character": 4}, "end": {"line": 6, "character": 9}}}
initialized-এর পরে কোনো <- নেই: notification-এর উত্তর হয় না। severity: 1 মানে Error; 2 হলো Warning, 3 Information, 4 Hint. দ্বিতীয় diagnostic-এর range 16–20, কারণ "60" token চার অক্ষরের। Hover-এর উত্তরে markdown লেখা আর যে নামের ওপর কার্সর তার range; definition-এর উত্তর একটি Location: uri আর range, এখানে লাইন ৭-এর var total. ল্যাবে একটি differential test-এ এই পাতার analyze-কে reference-এর check-এর সঙ্গে মিলিয়েছি:
~/haat/tool $ python -B diff_server.py
cases 4014 {'same': 3251, 'same-ok': 214, 'same-errors': 3037, 'first-line-same (reference recovered more syntax errors)': 763}
ইনপুট reference-এর ১৩টি উদাহরণ-ফাইল, cart.haat, আর এগুলো থেকে বানানো ৪০০০টি mutant (একটি token মুছে, দ্বিগুণ করে বা অন্য কিছু বসিয়ে)। ৩২৫১টিতে আউটপুট হুবহু এক, যার ২১৪টি “ok” আর ৩০৩৭টি error-ভরা। বাকি ৭৬৩টিতে প্রথম লাইন এক, কিন্তু reference আরও syntax error দেখিয়েছে: তার parser পর্ব ৫০-এর panic-mode recovery করে, আর haat_front-এর parser প্রথম error-এ থামে। অন্য কোনো পার্থক্য নেই। সত্যিকারের server-এ এই ফাঁক বন্ধ করতে পর্ব ৫০-এর recovering parser বসাতে হতো; অংশ ৬-এ দেখবেন কেন editor-এর জন্য এর চেয়েও বেশি লাগে।
Go-to-definition-এর আসল কাজ resolver আগেই করে রেখেছে। পর্ব ৫১-এর resolver প্রতিটি Var থেকে তার Binding-এ একটি সংযোগ (res.uses) রেখেছিল, scope chain ধরে খুঁজে। Server শুধু সেই সংযোগ উল্টো পথে editor-কে দেখায়। ঠিক করা লেখায় লাইন ১৩-এর দ্বিতীয় total-এ কার্সর:
7var total = price(2, 520);8{9 let total = price(1, 60) + 1;10 print(total);11}12print("🛒 মোট:");13total = total + 60;
| অবস্থান | |
| node | |
| scope chain |
- Request. Editor পাঠায়
textDocument/definition, অবস্থান line 12, character 9 (০ থেকে গোনা)। - রূপান্তর। লাইন ১৩-এ কার্সরের আগে শুধু ASCII, তাই UTF-16 unit = code point: Haat-এর অবস্থান 13:10.
- Node খোঁজা।
walkসব node দেখে। লাইন ১৩-এরAssign(column 1–5) মেলে না;Var totalcolumn 9 থেকে 13 পর্যন্ত, আর 10 তার ভেতরে। - Binding.
res.uses-এ এই node-এর binding আগেই রাখা। Resolver যখন লাইন ১৩-এ পৌঁছেছিল, লাইন ৮–১১-এর block-এর scope আগেই বন্ধ হয়ে গিয়েছিল; chain-এ ছিল শুধু top-level scope, যেখানেtotalমানে লাইন ৭-এরvar. - তুলনা: লাইন ১০। একই নাম, অন্য উত্তর। সেখানে chain-এর প্রথম scope ভেতরের block, যাতে
let total(9:9) আছে; খোঁজা প্রথম মিলেই থামে, তাই বাইরেরvarচোখে পড়ে না: shadowing. - Response. ঘোষণার অবস্থান 7:5, নামের দৈর্ঘ্য ৫, ০ থেকে গোনায় রূপান্তর: line 6, character 4 থেকে 9. Editor কার্সর সেখানে নিয়ে যায়।
শেষ ধাপ editor-এর দিক। Server-এর পাঠানো range থেকে লাল দাগ আঁকতে editor-কে character ঠিক এককে পড়তে হয়। নিচের JavaScript ব্লক লাইন ১২ আর server-এর দেওয়া diagnostic নিয়ে range-টিকে ⟦ ⟧ দিয়ে চিহ্নিত করে, তিনভাবে পড়ে: সঠিক UTF-16 unit, ভুল করে code point, আর ভুল করে UTF-8 byte.
"use strict";
// Line 12 of cart.haat and the diagnostic the Python server sent for it (copied from its output)
const text = 'print("🛒 মোট: " + total);';
const diag = { range: { start: { line: 11, character: 19 }, end: { line: 11, character: 24 } },
severity: 1, source: "haat", message: "type mismatch: expected Str, found Int" };
const { start: { character: s }, end: { character: e } } = diag.range;
const utf8 = [...new TextEncoder().encode(text)];
console.log("UTF-16 units:", text.length, "| code points:", [...text].length, "| UTF-8 bytes:", utf8.length);
// mark the range three ways: only the first is what LSP means by default
const show = (units, join) => join(units.slice(0, s)) + "⟦" + join(units.slice(s, e)) + "⟧" + join(units.slice(e));
const str = a => a.join(""), dec = a => new TextDecoder().decode(new Uint8Array(a));
console.log("UTF-16 units →", show(text.split(""), str)); // split("") gives UTF-16 code units
console.log("code points →", show([...text], str)); // [...s] gives code points
console.log("UTF-8 bytes →", show(utf8, dec));
// back to Haat's own column: count code points before the start
console.log(`12:${[...text.slice(0, s)].length + 1}: error: ${diag.message}`);আসল আউটপুট (ব্রাউজারের JavaScript; Node.js 24.15-এও একই):
UTF-16 units: 26 | code points: 25 | UTF-8 bytes: 34
UTF-16 units → print("🛒 মোট: " + ⟦total⟧);
code points → print("🛒 মোট: " + t⟦otal)⟧;
UTF-8 bytes → print("🛒 মো�⟦��: "⟧ + total);
12:19: error: type mismatch: expected Str, found Int
লাইনটিতে ২৫টি code point, কিন্তু ঝুড়ির emoji দুটি UTF-16 unit নেয় বলে ২৬ unit, আর UTF-8-এ ৩৪ byte. সঠিক পড়ায় দাগ ঠিক total-এর নিচে। Code point ধরে পড়লে দাগ এক ঘর ডানে সরে যায়: বাংলা-শুধু লাইনে এই bug লুকিয়ে থাকে, emoji এলেই ধরা পড়ে। Byte ধরে পড়লে দাগ একটি বাংলা অক্ষরের মাঝখান থেকে শুরু হয়, তাই ভাঙা অক্ষর (�)। শেষ লাইনে code point গুনে Haat-এর নিজের column 19 ফিরে এসেছে।
৬ · বাস্তবের compiler যখন server — tsc, clangd আর ভাঙা কোড
বড় ভাষাগুলোর server সাধারণত compiler-এর নিজের front end. TypeScript compiler (tsc)-এর --noEmit মানে শুধু check, কোনো JavaScript লেখা নয়; editor-এর লাল দাগ একই checker থেকে আসে। একটি TypeScript ফাইলে tsc 5.9.2-এর সত্যিকারের run:
~/ts $ cat bazar.ts
// বাজারঘর: অর্ডারের মোট দাম (TypeScript)
function price(qty: number, unit: number): number {
const p = qty * unit;
if (p >= 1000) { return p - p / 10; }
return p;
}
let total: number = price(2, "520");
const label: string = "🛒 মোট: " + total;
total = label;
console.log(totl);
~/ts $ tsc --noEmit --pretty false bazar.ts
bazar.ts(7,30): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
bazar.ts(9,1): error TS2322: Type 'string' is not assignable to type 'number'.
bazar.ts(10,13): error TS2552: Cannot find name 'totl'. Did you mean 'total'?
~/ts $ tsc --noEmit --pretty true bazar.ts (রং বাদ দিয়ে, শেষ অংশ)
bazar.ts:10:13 - error TS2552: Cannot find name 'totl'. Did you mean 'total'?
10 console.log(totl);
~~~~
bazar.ts:7:5
7 let total: number = price(2, "520");
~~~~~
'total' is declared here.
Found 3 errors in the same file, starting at: bazar.ts:7
লক্ষ করুন: প্রতিটি error-এর একটি স্থায়ী code (TS2345), যাতে নথি খোঁজা আর নির্দিষ্ট error চুপ করানো যায়; Did you mean 'total'?-এর পেছনে নামের দূরত্বের হিসাব; আর related information (“'total' is declared here”), যা LSP-র Diagnostic-এ relatedInformation হয়ে editor-এ যায়। বাস্তবে TypeScript-এর editor সমর্থন আসে tsserver থেকে, যার protocol LSP-র চেয়ে পুরোনো আর নিজস্ব; LSP-চাওয়া editor-এর জন্য একটি মধ্যস্থ adapter সেটি অনুবাদ করে। C/C++-এর জন্য LLVM প্রকল্পের clangd অংশ ৩-এর সেই Clang diagnostic আর fix-it সরাসরি LSP-তে দেয়; Rust-এর জন্য rust-analyzer, Python-এর জন্য Pyright-এর মতো server আছে।
ভাঙা কোডের সমস্যা। Compiler ভাঙা program পেলে error দিয়ে থামতে পারে। Editor-এর server পারে না: ব্যবহারকারী লিখছেন, তাই বেশির ভাগ সময় ফাইল ভাঙা। let x = price(2, লেখার মাঝপথে hover, completion আর বাকি ফাইলের লাল দাগ সবই চাই। এর জন্য error recovery-র চেয়েও বেশি লাগে: error-tolerant parsing, যেখানে parser সবসময় একটি গাছ দেয়, অনুপস্থিত token-এর জায়গায় “missing” node আর অচেনা অংশের জন্য “error” node বসিয়ে। অংশ ৫-এর ৭৬৩টি ক্ষেত্রে আমাদের server প্রথম syntax error-এর পরে অন্ধ; সেই সময় একটি ঘোষণা মুছে গেলে hover-ও কাজ করে না, কারণ res নেই। Roslyn (C#) আর rust-analyzer-এর parser সবসময় পূর্ণ গাছ দেয়। Tree-sitter (Max Brunsfeld-এর শুরু করা, GitHub-এ ২০১৮ সালের দিকে প্রকাশ্যে আসা) একটি parser generator, যা ভাঙা লেখাতেও গাছ দেয় আর ছোট বদলে গাছের শুধু প্রভাবিত অংশ আবার গড়ে; অনেক editor syntax highlighting-এর জন্য এটি ব্যবহার করে। এই পর্বে tree-sitter চালানো হয়নি, শুধু নাম উল্লেখ।
৭ · Incremental compilation — যা বদলায়নি তা আবার নয়
প্রতিটি অক্ষর টাইপের পর পুরো ফাইল, বা পুরো প্রজেক্ট, আবার বিশ্লেষণ করা হাজার ফাইলে অসম্ভব। Incremental compilation-এর মূল প্রশ্ন: আগের কাজের কোন অংশ এখনো সত্য? সবচেয়ে সরল উত্তর memoization: একটি হিসাবের ফল তার ইনপুট দিয়ে চিহ্নিত করে রাখা। ল্যাবে reference-এর lexer আর parser দিয়ে একটি ছোট পরীক্ষা: ফাইলকে top-level অংশে (item) ভাগ করি (প্রতিটি function, প্রতিটি top-level statement), প্রতিটি item আলাদা parse করি, আর ফল cache-এ রাখি item-এর লেখা দিয়ে চিহ্নিত করে। অবস্থান রাখা হয় item-এর শুরু থেকে আপেক্ষিক, আর ব্যবহারের সময় item-এর শুরুর লাইন যোগ করে পরম অবস্থানে নেওয়া হয়। প্রতিটি ধাপে ফল মেলানো হয় পুরো ফাইলের সাধারণ parse-এর সঙ্গে, প্রতিটি node-এর গঠন আর অবস্থান ধরে। bazar.haat-এ সত্যিকারের run (CPython 3.14.4):
~/haat/tool $ python -B incr.py
open bazar.haat items 9: parsed 9, reused 0; same tree and positions as a full parse: True
edit price: p / 10 -> p / 20 items 9: parsed 1, reused 8; same tree and positions as a full parse: True
add a line inside delivery items 9: parsed 1, reused 8; same tree and positions as a full parse: True
rename first -> first_order items 9: parsed 2, reused 7; same tree and positions as a full parse: True
1fn price(…) {…}2fn delivery(…) {…}3let first = …;4print(first);5var total = 0;6var rounds = 0;7while total < 5000 {…}8print(total);9print(rounds - 1);
| বদল | |
| parse হলো | |
| cache থেকে | |
| অবস্থান সরানো |
- প্রথম খোলা। Cache খালি, নয়টি item-ই parse হয়। প্রতিটির লেখা cache-এর চাবি।
- price-এর দেহে বদল। শুধু item ১-এর লেখা বদলেছে, তাই একটি parse; বাকি আটটির গাছ cache থেকে। ফল পুরো parse-এর সঙ্গে হুবহু এক।
- delivery-তে একটি লাইন যোগ। Item ২ নতুন করে parse হয়। Item ৩–৯ এক লাইন নিচে নেমেছে, কিন্তু তাদের লেখা একই, আর cache-এ অবস্থান আপেক্ষিক; তাই শুধু শুরুর লাইন বদলে পুনর্ব্যবহার। পরম অবস্থান রাখলে সাতটি item-ই cache-miss হতো।
- নাম বদল।
firstদুটি item-এ আছে (item ৩ আর ৪), তাই দুটি parse, সাতটি পুনর্ব্যবহার। - পরের স্তরে। Parse-এর পরে type check. ধাপ ২-এর বদল price-এর দেহে, signature একই:
(Int, Int) -> Int. যে function শুধু price-কে ডাকে, তার type check-এর ইনপুট (price-এর signature) বদলায়নি, তাই আগের ফল চলে। এর নাম early cutoff: একটি ধাপের ফল আগের মতো হলে তার ওপরের হিসাব থামে।
শিল্পে এই ধারণার দুটি বড় রূপ। Red–green tree (C#-এর Roslyn compiler-এ, যা ২০১৪ সালে open source হয়): “green” node অপরিবর্তনীয় (immutable), শুধু নিজের ধরন, সন্তান আর দৈর্ঘ্য জানে, অবস্থান বা parent নয়; তাই একই green subtree অনেক জায়গায় ভাগ করা যায়, ঠিক উপরের আপেক্ষিক অবস্থানের মতো। “Red” node একটি পাতলা আবরণ, যা চাহিদামতো তৈরি হয় আর parent ও পরম অবস্থান হিসাব করে। একটি অক্ষর বদলালে শুধু বদলানো পথের green node নতুন হয়। rust-analyzer-এর syntax tree-ও একই নকশার বলে তাদের নথিতে বলা আছে। Query-based compiler: compiler-কে একটি বড় pipeline নয়, অনেক ছোট pure function (“query”) হিসেবে লেখা, যেমন parse(file), signature(fn), type_of(expr), যারা একে অপরকে ডাকে। একটি কাঠামো কে কাকে ডাকল তা মনে রাখে (dependency graph), আর ইনপুট বদলালে শুধু প্রভাবিত query আবার চালায়, early cutoff সহ। rustc-র incremental compilation আর rust-analyzer-এর Salsa কাঠামো এই পথে চলে; rustc-র নথিতে বদল চিহ্নিত করার কৌশলটিকেও “red-green” বলা হয় (গাছের নয়, dependency graph-এর রং)।
আরও গভীরে: Andrey Mokhov, Neil Mitchell আর Simon Peyton Jones-এর ২০১৮ সালের প্রবন্ধ “Build Systems à la Carte” দেখায় যে make, Excel আর অনেক build system একই দুটি প্রশ্নের ভিন্ন উত্তর: কোন ক্রমে কাজ চালাবে (scheduler), আর একটি কাজ আবার চালানো দরকার কি না (rebuilder: timestamp, hash বা “trace” দেখে)। Early cutoff সেখানে একটি স্পষ্ট বৈশিষ্ট্য। অর্থাৎ incremental compiler আর build system মূলত একই তত্ত্ব, শুধু একক আলাদা: একটির query একটি function-এর type, অন্যটির একটি পুরো ফাইল। ১৯৮০-এর দশকে Reps আর Teitelbaum-এর Synthesizer Generator-এর মতো ব্যবস্থায় incremental attribute evaluation নিয়ে কাজ হয়েছিল (পর্ব ৫৩), যা আজকের ধারণার পূর্বসূরি।
৮ · Debugger, REPL, package manager আর build system
Debugger. Compiler machine code বানানোর সময় একটি মানচিত্রও লিখতে পারে: কোন address কোন source লাইনের, কোন variable কোন register বা stack-এর ঘরে। এই debug info-র প্রচলিত format হলো DWARF (১৯৮০-এর দশকের শেষে Unix System V-এর সঙ্গে শুরু; সংস্করণ ৫ প্রকাশিত হয় ২০১৭ সালে)। gdb বা lldb সেই মানচিত্র পড়ে: আপনি “লাইন ১২-এ থামুন” বললে debugger লাইন-টেবিল থেকে address বের করে সেখানে একটি trap instruction বসায়। Optimization (-O2) এই মানচিত্র জটিল করে: একটি variable হয়তো কোথাও নেই, কারণ compiler তাকে মুছে দিয়েছে, যাকে debugger বলে “optimized out”. Object file-এ debug info কোথায় থাকে, তা পর্ব ৭৪-এর (Linking আর loading) বিষয়; ব্যবহারের দিক আছে C কোর্সের পর্ব ৩১-এ. Editor আর debugger-এর মাঝে LSP-র এক সহোদরও আছে, Debug Adapter Protocol.
REPL. Read–Eval–Print Loop: একটি লাইন পড়া, চালানো, ফল দেখানো, আবার। ধারণাটি LISP-এর ১৯৬০-এর দশকের পরিবেশ থেকে। ভাষা-নির্মাতার কাছে প্রশ্নটি কৌশলের: প্রতিটি লাইন যেন একটি নতুন program-এর শেষ statement, কিন্তু আগের লাইনের binding থেকে যাবে। Haat-এর REPL-এ তাই resolver আর checker-এর top-level scope আর interpreter-এর environment লাইনে লাইনে বেঁচে থাকতে হবে, আর একটি ভুল লাইন যেন আগের অবস্থা নষ্ট না করে। Spec সিদ্ধান্ত ১৫ (একই scope-এ দুবার ঘোষণা error) REPL-এ বিরক্তিকর: let x = 1; ভুল লিখে আবার লেখা যায় না। অনেক ভাষার REPL তাই এখানে নিয়ম শিথিল করে, যা পর্ব ১২-এর (scripting আর dynamic ভাষা) সঙ্গে মিলে যায়।
Package manager আর build system. একটি ভাষা টিকে থাকে তার ecosystem দিয়ে। Package manager প্রশ্নের উত্তর দেয় “কোন library-র কোন version লাগবে”: dependency graph থেকে মিলিয়ে একটি সংস্করণ-সমাধান বের করা (সাধারণভাবে কঠিন সমস্যা), আর সেই সমাধান একটি lockfile-এ লিখে রাখা, যাতে সবার মেশিনে একই জিনিস। Build system প্রশ্নের উত্তর দেয় “কী আবার compile করতে হবে”: ১৯৭৬ সালে Bell Labs-এ Stuart Feldman-এর make ফাইলের সময় (timestamp) দেখত; আধুনিক ব্যবস্থা content hash দেখে, যা অংশ ৭-এর cache-এর মতোই। পর্ব ১৮-এর module ব্যবস্থা ঠিক করে কোন ফাইল কোনটির ওপর নির্ভর করে। ব্যবহারের দিক আছে অন্য কোর্সে: C++ কোর্সের পর্ব ৪৯ (CMake), Python কোর্সের পর্ব ২৩ (pip আর venv), আর Full-Stack কোর্সের পর্ব ৭৯ (build আর bundling).
পরীক্ষা ও ইন্টারভিউতে: (১) Formatter idempotent হলেই কি সঠিক? না; অর্থ অটুট (parse(fmt(s)) ≅ parse(s)) আলাদা শর্ত, আর সেটি থেকেই idempotence আসে। (২) LSP কোন সমস্যা সমাধান করে? M editor × N ভাষার M × N plugin-কে M + N বাস্তবায়নে নামায়। (৩) Request আর notification-এর পার্থক্য? Request-এ id থাকে আর ঠিক একটি response আসে; notification-এ id নেই, উত্তরও নেই। (৪) LSP-র ডিফল্ট অবস্থান-একক? ০ থেকে গোনা line আর UTF-16 code unit. (৫) Incremental compiler কেন আপেক্ষিক অবস্থান রাখে? আগের অংশে লাইন যোগ হলেও পরের অংশের গাছ পুনর্ব্যবহার করা যায়।
৯ · AI-এর যুগে language tooling
AI coding assistant নিজেই এখন editor-এর একটি tool, আর language server-এর সঙ্গে পাশাপাশি কাজ করে। কিন্তু tooling নিয়ে প্রশ্ন করলে AI প্রায়ই নির্দিষ্ট ভুল করে:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
LSP-র character-কে code point বা byte ধরা; line ১ থেকে গোনা | emoji আর বাংলা থাকা লাইনে পরীক্ষা; specification-এর Position অংশ পড়া |
| অস্তিত্বহীন method, capability বা compiler flag বানানো | Specification-এর সংস্করণ মিলিয়ে নাম খোঁজা; flag চালিয়ে দেখা |
| Formatter বা “refactor” যা অর্থ বদলায় (বন্ধনী মোছা, evaluation order বদল) | আগে-পরে AST তুলনা; দুই রূপ চালিয়ে আউটপুট মেলানো |
| Rename-এ শুধু লেখা খুঁজে বদলানো, scope না দেখে | Resolver-এর binding ধরে rename; shadowing-ওয়ালা উদাহরণে পরীক্ষা |
| এক ভাষার নিয়ম সবখানে (“unused variable সবসময় শুধু warning”) | ভাষা আর সংস্করণ ধরে compiler চালানো (Go-তে এটি error) |
| Compiler-এর বার্তা বা diagnostic code বানিয়ে লেখা | সত্যিকারের compiler চালিয়ে আসল আউটপুট কপি করা |
AI-কে ভালোভাবে কাজে লাগানোর উপায়: কোডের সঙ্গে property আর পরীক্ষার পরিকল্পনা চাওয়া, তারপর নিজে চালানো।
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১LSP-র আগে IDE-গুলো কীভাবে ভাষা সমর্থন দিত, LSP কেন এত দ্রুত ছড়াল, আর এর দুর্বলতা কোথায়?
LSP-র আগে দুটি পথ ছিল। বড় IDE (Eclipse, IntelliJ, Visual Studio) প্রতিটি ভাষার জন্য নিজের বিশ্লেষক লিখত, প্রায়ই compiler-এর বাইরে আলাদা parser আর type checker দিয়ে; ফল ভালো, কিন্তু খরচ বিপুল, আর compiler-এর সঙ্গে সূক্ষ্ম অমিল থেকেই যেত। ছোট editor (Vim, Emacs, Sublime) regex-ভিত্তিক highlighting আর বাইরের tool-এর আউটপুট পড়ে কাজ চালাত। প্রতিটি editor-ভাষা জোড়া আলাদা প্রকল্প, অংশ ১-এর M × N.
LSP-র সাফল্যের তিনটি কারণ। প্রথম, অর্থনীতি: একটি ভাষার দল একটি server লিখলেই সব editor পায়, আর একটি editor একটি client লিখলেই সব ভাষা পায়। দ্বিতীয়, server আলাদা process, তাই যেকোনো ভাষায় লেখা যায়, সাধারণত ভাষাটির নিজের compiler-এর ভেতরেই (clangd, rust-analyzer, gopls-এর মতো)। ফলে editor আর compiler একই কথা বলে। তৃতীয়, VS Code-এর জনপ্রিয়তা একটি বড় ব্যবহারকারী-ভিত্তি দিয়েছিল।
দুর্বলতাও আছে। অবস্থানের ডিফল্ট UTF-16 একটি JavaScript-কেন্দ্রিক উত্তরাধিকার, যার জন্য UTF-8-এ লেখা প্রায় প্রতিটি server-কে রূপান্তর করতে হয়, আর অংশ ৫-এর মতো bug আসে; 3.17-এ positionEncoding আলোচনা যোগ হলেও utf-16 বাধ্যতামূলক রয়ে গেছে। JSON বার্তা বড় ফাইলে ভারী। Protocol সব ভাষার “সাধারণ গুণনীয়ক”: একটি ভাষার বিশেষ ক্ষমতা (যেমন macro-র expansion দেখানো) প্রায়ই protocol-এর বাইরের নিজস্ব extension হয়ে যায়। আর Full sync-এ প্রতিটি অক্ষরে পুরো ফাইল পাঠানো; সেই কারণে Incremental sync আছে, কিন্তু তাতে client-server-এর লেখা অমিল হওয়ার নতুন bug-ও আসে।
একটি ঐতিহাসিক টীকা: এই নকশা একেবারে নতুন নয়। আগের দশকে কিছু editor বাইরের process-এর সঙ্গে নিজস্ব protocol-এ কথা বলত (যেমন OmniSharp বা TypeScript-এর tsserver-এর ক্ষেত্রে)। LSP সেগুলোকে একটি সাধারণ, প্রকাশ্য চুক্তিতে রূপ দেয়।
মূল উপলব্ধি: LSP প্রযুক্তিগতভাবে সরল, কিন্তু অর্থনৈতিকভাবে বিপ্লবী: M × N-কে M + N করা। এর দুর্বলতাগুলো সেই সরলতারই মূল্য।
প্র ০২gofmt, Prettier আর Black প্রায় কোনো বিকল্প দেয় না। কোডের ধাঁচ নিয়ে স্বাধীনতা কেড়ে নেওয়া কেন জনপ্রিয় হলো?
Go ২০০৯ সালে প্রকাশের সময় থেকেই gofmt নিয়ে আসে, আর Go সম্প্রদায়ে একটি কথা প্রচলিত: gofmt-এর ধাঁচ কারও প্রিয় নয়, তবু gofmt সবার প্রিয়। কারণটি প্রযুক্তিগত নয়, সামাজিক। Indentation, বন্ধনীর জায়গা, লাইনের দৈর্ঘ্য নিয়ে তর্ক (যাকে ইংরেজিতে bikeshedding বলে) একটি দলের অনেক সময় খায়, আর code review-তে আসল প্রশ্ন ঢেকে দেয়। Formatter সেই প্রশ্নটিকেই মুছে দেয়: ধাঁচ যন্ত্রের দায়িত্ব।
দ্বিতীয় সুবিধা version control-এ। সবাই একই formatter চালালে diff-এ শুধু আসল বদল থাকে; কারও editor tab আর কারও space বসালে প্রতিটি লাইন “বদলানো” দেখায়। তৃতীয়, idempotence আর layout-অন্ধতা (সংজ্ঞা ৮০.১-এর F1, F2) থাকলে formatter-কে CI-তে একটি পরীক্ষা হিসেবে চালানো যায়: “fmt চালালে কি ফাইল বদলায়?” না বদলালে পাস।
JavaScript-এর Prettier (২০১৭) একই দর্শন আনে, আর Python-এর Black (২০১৮ সালের দিকে) নিজেকে “uncompromising” বলে। দুটিই Wadler-ধাঁচের লাইন-ভাঙার algorithm ব্যবহার করে: একটি গ্রুপ এক লাইনে ধরলে রাখা, না ধরলে ভাঙা। এর ফলে একটি সূক্ষ্ম প্রভাব: একটি নাম বড় করলে দূরের লাইনও ভেঙে যেতে পারে, তাই diff কখনো প্রত্যাশার চেয়ে বড় হয়।
মূল্যও আছে। কোনো কোনো জায়গায় হাতে সাজানো রূপ বেশি পাঠযোগ্য (যেমন matrix-এর মতো সারিবদ্ধ সংখ্যা), তাই বেশির ভাগ formatter একটি “এখানে হাত দিও না” comment মানে। আর formatter-এর নিজের bug বিপজ্জনক: অংশ ২-এর বন্ধনী-ভোলা printer দেখিয়েছে, এমন bug idempotence পরীক্ষায় ধরা পড়ে না। তাই Black-এর মতো tool নিজের আউটপুটের AST আগের AST-এর সঙ্গে মেলায় বলে তাদের নথিতে উল্লেখ আছে, ঠিক F3 শর্ত।
মূল উপলব্ধি: বিকল্পহীন formatter একটি সামাজিক সমস্যা যন্ত্র দিয়ে সমাধান করে; আর তার নিজের সঠিকতার প্রমাণ “একই AST”, “একই চেহারা” নয়।
প্র ০৩Haat-এর reference একটি batch compiler: ফাইল পড়ে, ধাপে ধাপে চলে, শেষ। IDE-র জন্য এই নকশা কেন খারাপ, আর Roslyn বা rust-analyzer কী বদলেছে?
Batch compiler তিনটি অনুমান করে। এক, ইনপুট সম্পূর্ণ আর প্রায়ই সঠিক। দুই, একবার চালানো, তাই আগের run-এর কিছু মনে রাখার দরকার নেই। তিন, আউটপুট একটি ফাইল বা error-তালিকা, কোনো প্রশ্নের উত্তর নয়। IDE-তে তিনটিই ভাঙে: ইনপুট প্রায় সবসময় ভাঙা, প্রতি সেকেন্ডে কয়েকবার বদলায়, আর প্রশ্ন আসে নির্দিষ্ট (“এই নামের type কী?”), পুরো আউটপুট নয়।
Haat-এর reference-এ এর প্রভাব স্পষ্ট। Parser প্রথম syntax error-এ গাছ দেয় না (recovery করে error-তালিকা দেয়, কিন্তু program নয়), resolver ব্যর্থ হলে checker চলে না, আর প্রতিটি run শূন্য থেকে শুরু। অংশ ৫-এর server এর ওপর বসেছে বলে প্রতিটি hover-এ পুরো ফাইল আবার বিশ্লেষণ করে।
Microsoft-এর C# আর Visual Basic compiler নতুন করে লেখা হয় Roslyn নামে (open source ২০১৪), “compiler as a platform” ধারণায়: syntax tree, semantic model আর diagnostic সবই public API, আর একই code compiler আর IDE দুজনেই ব্যবহার করে। Red–green tree (অংশ ৭) এর কেন্দ্রে: অপরিবর্তনীয় green node পুরোনো আর নতুন সংস্করণে ভাগ হয়, তাই একটি অক্ষর বদলালে নতুন গাছ সস্তা, আর পুরোনো গাছ নিরাপদে অন্য thread পড়তে পারে।
Rust-এ rustc মূলত batch compiler ছিল; পরে এর ভেতরে query system আর incremental compilation আসে। rust-analyzer (২০১৮ সালের দিকে শুরু) প্রথম থেকেই IDE-র জন্য নকশা: lossless, error-tolerant syntax tree, আর Salsa নামের query কাঠামো, যেখানে প্রতিটি তথ্য (একটি ফাইলের গাছ, একটি function-এর signature) একটি memoized query. একটি অক্ষর বদলালে শুধু নির্ভরশীল query অবৈধ হয়, আর early cutoff-এ বেশির ভাগ কাজ সেখানেই থামে।
মূল উপলব্ধি: IDE-র compiler একটি pipeline নয়, একটি প্রশ্নোত্তরের database: ভাঙা ইনপুট মেনে নেয়, আগের উত্তর মনে রাখে, আর শুধু জিজ্ঞাসা করা অংশটুকু হিসাব করে।
প্র ০৪পর্ব ৫০-এর panic-mode recovery compiler-এর জন্য যথেষ্ট। Editor-এর জন্য কেন নয়, আর error-tolerant parser কী আলাদা করে?
Panic-mode recovery-র লক্ষ্য একটি run-এ যত বেশি আসল error দেখানো, cascade এড়িয়ে। Parser একটি error দেখে নিরাপদ বিন্দু (; বা }) পর্যন্ত লাফ দেয়, মাঝের অংশ ফেলে দেয়। Compiler-এর জন্য এটি ঠিক: ব্যবহারকারী error-তালিকা পান, সেরে আবার চালান। কিন্তু ফেলে দেওয়া অংশ থেকে কোনো গাছ বা binding তৈরি হয় না।
Editor-এর চাহিদা অন্য। ব্যবহারকারী let first = price(2, লিখে থেমে আছেন; ঠিক এই মুহূর্তে তিনি completion চান (price-এর দ্বিতীয় parameter কী?), আর বাকি ফাইলের hover-ও চলা উচিত। Panic mode এই অসম্পূর্ণ statement পুরো ফেলে দিত, ফলে first বলে কিছু থাকত না, আর পরের লাইনের print(first)-এ “undefined variable” লাল দাগ উঠত, যা বিভ্রান্তিকর।
Error-tolerant parser সবসময় একটি পূর্ণ গাছ দেয়। অনুপস্থিত ) আর ;-এর জায়গায় শূন্য-দৈর্ঘ্যের “missing” token, আর বোঝা যায় না এমন token-এর চারপাশে একটি “error” node. Roslyn এভাবে কাজ করে; tree-sitter-ও ভাঙা ইনপুটে ERROR আর MISSING node দেয় বলে তার নথিতে বলা আছে। এতে first-এর ঘোষণা গাছে থাকে, type না জানা গেলেও নাম জানা যায়, আর পরের লাইন পরিষ্কার থাকে।
অংশ ৫-এর পরিসংখ্যান এই পার্থক্য মাপে: ৪০১৪টি ক্ষেত্রের ৭৬৩টিতে আমাদের প্রথম-error-এ-থামা parser reference-এর চেয়ে কম error দেখিয়েছে। আর সেসব ক্ষেত্রে hover আর definition-ও অন্ধ, কারণ res নেই। একটি সত্যিকারের Haat server-এর প্রথম উন্নতি হবে parser-কে সবসময় গাছ দিতে শেখানো, আর resolver ও checker-কে error node-এর পাশ কাটিয়ে চলতে শেখানো, যেমন পর্ব ৫২-এর checker None type দিয়ে cascade থামায়।
মূল উপলব্ধি: Compiler-এর recovery error গোনার জন্য; editor-এর recovery কাজ চালিয়ে যাওয়ার জন্য। দ্বিতীয়টির জন্য গাছ কখনো অনুপস্থিত হতে পারে না।
প্র ০৫Lint-এর জন্ম ১৯৭০-এর দশকের শেষে। আজ compiler নিজেই অনেক সতর্কবার্তা দেয়। তাহলে আলাদা linter কেন টিকে আছে, আর warning-কে error বানানো কি ভালো?
মূল lint Bell Labs-এ Stephen C. Johnson লেখেন (১৯৭৮ সালের কাছাকাছি)। তখনকার C compiler ছোট মেশিনে চলত আর দ্রুত হতে চাইত, তাই সন্দেহজনক কোড খোঁজার বাড়তি বিশ্লেষণ আলাদা program-এ রাখা হয়েছিল, যেমন ফাংশনের ঘোষণা আর ব্যবহারে argument-এর অমিল, বিভিন্ন ফাইল জুড়ে। পরে compiler-ই অনেক নিয়ম নিজের ভেতরে নেয়, অংশ ৩-এর Clang -Wall-এর মতো।
তবু আলাদা linter টিকে আছে তিন কারণে। প্রথম, ধাঁচের নিয়ম (নামকরণ, ফাংশনের দৈর্ঘ্য, নির্দিষ্ট API নিষেধ) ভাষার অংশ নয়, দলের নিয়ম; compiler-এর এসব জানার কথা নয়। দ্বিতীয়, linter দ্রুত বদলায়: নতুন নিয়ম যোগ করতে compiler-এর নতুন সংস্করণ লাগে না। তৃতীয়, dynamic ভাষায় (Python, JavaScript) চালানোর আগে কোনো compiler সব দেখে না; সেখানে linter-ই প্রথম পাহারাদার। Python-এর Ruff-এর মতো নতুন linter গতির জন্য Rust-এ লেখা, আর অনেক পুরোনো tool-এর নিয়ম একসাথে দেয় বলে তার নথিতে বলা আছে।
Warning-কে error (-Werror) বানানো একটি আপস। সুবিধা: সতর্কবার্তা জমে জমে অগ্রাহ্য হওয়া বন্ধ হয়। অসুবিধা: compiler-এর নতুন সংস্করণ নতুন warning যোগ করলে পুরোনো কোড হঠাৎ build হয় না। তাই অনেক দল CI-তে -Werror রাখে কিন্তু ব্যবহারকারীর build-এ রাখে না। Go ভাষা-নকশাতেই কয়েকটি সিদ্ধান্ত নিয়েছে: অব্যবহৃত import আর local variable সরাসরি compile error, বাকি সন্দেহের জন্য go vet.
এবং মৌলিক সীমাটি মনে রাখুন: Rice-এর উপপাদ্য অনুযায়ী program-এর কোনো অর্থগত বৈশিষ্ট্য সাধারণভাবে নিখুঁতভাবে যাচাই করা যায় না। তাই প্রতিটি linter নিয়ম হয় কিছু ভুল সতর্কতা দেবে, নয় কিছু সমস্যা ছেড়ে দেবে। ভালো নিয়মের মাপকাঠি তাই ব্যবহারিক: সতর্কতার কত অংশ সত্যি, আর মিথ্যা হলে চুপ করানো কত সহজ।
মূল উপলব্ধি: Compiler বলে “ভাষা কী নিষেধ করে”, linter বলে “আমরা কী এড়াতে চাই”। দ্বিতীয়টি সামাজিক চুক্তি, তাই আলাদা tool-এ বদলানো সহজ।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। আউটপুটগুলো এই পাতার server, Haat reference আর CPython 3.14.4-এ চালিয়ে মেলানো।
-
বাস্তবায়ন —
textDocument/rename: অংশ ৫-এর server-এ rename যোগ করুন। Request-এ থাকে একটি অবস্থান আরnewName; উত্তর একটিWorkspaceEdit:{"changes": {uri: [TextEdit, …]}}, প্রতিটি TextEdit একটিrangeআরnewText. শুধু লেখা খুঁজে বদলালে কী ভুল হতো? কোন ক্ষেত্রে rename প্রত্যাখ্যান করবেন?লেখা খুঁজে বদলালে
cart.haat-এর ভেতরেরlet totalrename করতে গিয়ে বাইরেরvar total-ও বদলে যেত। সঠিক পথ resolver-এর binding: যে node-গুলোর binding ঠিক এইBindingobject (isদিয়ে তুলনা), সেগুলোই বদলাবে, ঘোষণাসহ। অংশ ৫-এর দুই ব্লকের পরে এই function লাগালে চলে:def rename(text, position, new): # textDocument/rename -> WorkspaceEdit (or None) _, program, res = analyze(text) if res is None: return None _, b = binding_at(program, res, *from_lsp(text, position)) names = {t.text for t in tokenize(text) if t.kind == "IDENT"} if b is None or not re.fullmatch(r"[A-Za-z_]\w*", new) or new in KW or new in names: return None # conservative: the new name must be unused everywhere spots = [x for x in walk(program.stmts) if (res.uses.get(id(x)) or res.decls.get(id(x))) is b] return {"changes": {"file:///home/haat/cart.haat": [{"range": span(text, x.line, x.col, len(b.name)), "newText": new} for x in spots]}}ঠিক করা
cart.haat-এ (fixed) সত্যিকারের run: লাইন ১০-এরtotalথেকেsmall-এ rename দেয় দুটি TextEdit, শুরু (8, 8) আর (9, 10), অর্থাৎ শুধু ভেতরেরletআর তার ব্যবহার; লাইন ১৩-এরtotalথেকে দেয় তিনটি: (6, 4), (12, 0), (12, 8). নতুন নামpriceবাwhileহলে উত্তরNone.প্রত্যাখ্যানের কারণ: নতুন নাম অবৈধ identifier বা keyword; একই scope-এ আগে থেকে আছে (spec সিদ্ধান্ত ১৫-এর error হবে); অথবা নতুন নাম ভেতরের কোনো নামকে ঢেকে দেবে বা নিজে ঢাকা পড়বে (shadowing বদলে অর্থ বদলাবে)। এখানে সবচেয়ে সাবধানী নিয়ম নেওয়া: নামটি ফাইলের কোথাও থাকলেই না। আরও উদার কিন্তু নিরাপদ পথ: rename করে আবার resolve করা, আর দেখা যে প্রতিটি পুরোনো ব্যবহার এখনো একই ঘোষণায় যায় আর অন্য কোনো ব্যবহার এই ঘোষণায় আসেনি।
-
ভুল খুঁজুন আর প্রমাণ করুন: একজন দাবি করলেন, “আমার formatter idempotent, তাই এটি অর্থ বদলায় না।” (ক) একটি প্রতি-উদাহরণ দিন। (খ) উল্টো দিকটি প্রমাণ করুন: যদি প্রতিটি বৈধ লেখা s-এর জন্য parse(fmt(s)) ≅ parse(s) হয় (F3), আর
prettyশুধু গাছের গঠন দেখে, অবস্থান নয়, তাহলে fmt idempotent.(ক) অংশ ২-এর বন্ধনী-ভোলা printer:
let d = -(a + b) * c;→let d = -a + b * c;. আবার চালালে-a + b * c-ই থাকে, তাই idempotent (পরীক্ষায় ৪০০-তে ৪০০), অথচ AST বদলেছে (৪০০-এর ৮৯টিতে)। অতএব idempotence ⇏ অর্থ অটুট।(খ) প্রমাণ। t = fmt(s) = pretty(parse(s)) ধরি।
- F3 s-এর জন্য: parse(t) = parse(fmt(s)) ≅ parse(s). এখানে ধরে নেওয়া হয় t বৈধ লেখা (F3-এর অংশ: parse(t) সফল)।
- pretty শুধু গঠন দেখে: দুটি গাছ ≅ হলে তাদের pretty একই লেখা। অতএব pretty(parse(t)) = pretty(parse(s)).
- বাঁ দিক সংজ্ঞায় fmt(t) = fmt(fmt(s)), ডান দিক fmt(s). তাই fmt(fmt(s)) = fmt(s). ∎
দ্বিতীয় ধাপের শর্তটি জরুরি: printer যদি অবস্থান দেখে সিদ্ধান্ত নিত (যেমন “মূল লেখায় যেখানে লাইন ভাঙা ছিল সেখানে ভাঙো”), তাহলে F3 থাকলেও idempotence ভাঙতে পারত। এই যুক্তি অনুযায়ী F2-ও আসে: s আর s′-এর token একই হলে parse(s) ≅ parse(s′), তাই একই pretty.
-
হিসাব করুন: Haat-এর লাইন
print("চা🍵" + 5);(ফাইলের প্রথম লাইন)। (ক) Referencecheckকোন অবস্থানে কী error দেবে? (খ) সেই অবস্থান LSP-তে utf-16, utf-32 আর utf-8 encoding-এ কত? (গ) পুরো লাইনটি code point, UTF-16 unit আর UTF-8 byte-এ কত লম্বা?(ক)
+-এর বাঁ দিক Str, তাই ডান দিক Str হওয়ার কথা; ভুল ডান operand5-এর শুরুতে।print(৬, তারপর string token-এ ৫টি code point (", চ, া, 🍵,"), space,+, space: ১৪টি code point আগে, তাই column 15. Reference-এর সত্যিকারের আউটপুট:1:15: error: type mismatch: expected Str, found Int.(খ) line 0. utf-32 (code point, ০ থেকে): 14. utf-16: 🍵 BMP-র বাইরে, দুটি unit, তাই 15. utf-8:
print(৬ + দুটি"২ + চ ৩ + া ৩ + 🍵 ৪ + দুটি space আর+৩ = 21.(গ) ১৭টি code point, ১৮টি UTF-16 unit, ২৪ byte (newline বাদে)। সব সংখ্যা Python-এ
len(s),len(s.encode("utf-16-le")) // 2আরlen(s.encode())দিয়ে মেলানো। -
আউটপুট অনুমান করুন: অংশ ৭-এর incremental parser-এ
bazar.haatখোলার পরে (cache-এ নয়টি item) যদিrounds-এর নাম সব জায়গায়turnsকরা হয়, কয়টি item আবার parse হবে আর কয়টি cache থেকে আসবে? তারপর যদি ফাইলের একেবারে শুরুতে একটি নতুন comment লাইন যোগ হয়?roundsআছে তিনটি item-এ:var rounds = 0;,whileloop (দেহেrounds = rounds + 1;), আরprint(rounds - 1);. তাই parse ৩, cache থেকে ৬.শুরুতে comment যোগ করলে সব item এক লাইন নিচে নামে, কিন্তু item-এর লেখা (প্রথম token থেকে শেষ token) বদলায় না, কারণ comment কোনো item-এর ভেতরে পড়েনি। তাই parse ০, cache থেকে ৯, শুধু অবস্থান সরানো। ল্যাবে
incr.py-এর একই কাঠামোয় দুটিই চালিয়ে মিলেছে, আর দুই ক্ষেত্রেই ফল পুরো parse-এর সঙ্গে (গঠন আর অবস্থান) এক।
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি LSP অধিবেশনে editor একটি ফাইল খোলে, server ভুল জানায়, ব্যবহারকারী ভুল সারান, তারপর editor বন্ধ হয়। বার্তাগুলো কোন ক্রমে যায়, সাজান (▲▼ চেপে সরান):
- initialize (request) আর তার response
- initialized (notification)
- textDocument/didOpen
- textDocument/publishDiagnostics (ভুলসহ)
- textDocument/didChange
- shutdown (request), তারপর exit
একটি Haat লাইন print("🛒 মোট: " + total);-এ total শুরু হয় Haat-এর column 19-এ (১ থেকে গোনা, code point ধরে)। LSP-র ডিফল্ট encoding-এ (০ থেকে গোনা) এর character কত?
- 18
- 19
- 20
- 27
একটি Haat formatter-এর printer কখনো বন্ধনী লেখে না, তাই -(a + b) * c হয়ে যায় -a + b * c. এই formatter সম্পর্কে কোনটি ঠিক?
- এটি idempotent নয়, তাই fmt(fmt(x)) পরীক্ষাতেই bug ধরা পড়বে
- এটি layout-এ অন্ধ নয়
- এটি idempotent, তবু অর্থ বদলায়; ধরা পড়ে শুধু “একই AST” পরীক্ষায়
- এর আউটপুট parse হয় না
LSP-তে নিচের কোন বার্তার কোনো উত্তর (response) আসে না?
initialize- textDocument/hover
- textDocument/definition
- textDocument/publishDiagnostics
একটি প্রতিষ্ঠানে ৫টি editor আর ৮টি প্রোগ্রামিং ভাষা। প্রতিটি editor-এ প্রতিটি ভাষার সমর্থন দিতে LSP ছাড়া আর LSP দিয়ে কয়টি বাস্তবায়ন লাগে?
- ৪০ আর ১৩
- ১৩ আর ৪০
- ৪০ আর ৫
- ৪০ আর ১
একটি incremental parser প্রতিটি top-level item-এর গাছ cache-এ রাখে, item-এর লেখা দিয়ে চিহ্নিত করে। গাছের অবস্থান item-এর শুরু থেকে আপেক্ষিক রাখার প্রধান সুবিধা কী?
- প্রতিটি item আরও দ্রুত parse হয়
- ফাইলের আগের অংশে লাইন যোগ হলেও পরের item-এর গাছ পুনর্ব্যবহার করা যায়
- Error message ছোট হয়
- Type checking আর লাগে না
একটি linter-এর নিয়ম “এই variable-এর মান কখনো ব্যবহার হয় না” সতর্ক করে। কখনো সে ভুল সতর্ক করে, কখনো আসল সমস্যা ছেড়ে দেয়। এর মৌলিক কারণ কী?
- Linter-এর লেখকেরা যথেষ্ট যত্ন নেননি
- AST-এ variable-এর ব্যবহারের তথ্য থাকে না
- Program-এর অর্থগত বৈশিষ্ট্য সাধারণভাবে undecidable (Rice-এর উপপাদ্য)
- Linter program না চালালে কিছুই বলতে পারে না
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- Tool = একই front end: formatter হলো parse তারপর pretty, linter হলো AST-এর ওপর বাড়তি pass, hover আর definition হলো resolver-এর binding পড়া।
- Formatter-এর শর্ত: idempotent, layout-অন্ধ আর অর্থ অটুট। শেষটি থেকে প্রথমটি আসে, উল্টো নয়; বন্ধনী-ভোলা printer ৪০০-তে ৪০০ বার স্থির থেকেও ৮৯ বার অর্থ বদলেছে।
- LSP: Content-Length header আর JSON-RPC 2.0; request-এ id আর একটি response, notification-এ কিছুই না। Position ০ থেকে, ডিফল্টে UTF-16 unit; 🛒-ওয়ালা লাইনে Haat-এর column থেকে আলাদা।
- Haat server: ৪০১৪টি ক্ষেত্রে ৩২৫১টিতে reference
check-এর হুবহু সমান, বাকি ৭৬৩টিতে শুধু reference বেশি syntax error দেখায়; editor-এর জন্য error-tolerant parser লাগবে। - Incremental: আপেক্ষিক অবস্থানসহ item-cache-এ এক function বদলালে নয়টির একটি parse; red–green tree আর query-based compiler এই ধারণার শিল্প-রূপ, early cutoff সহ।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৮১ · ক্যাপস্টোন — Haat-এর পূর্ণ compiler, source থেকে চলমান programপরবর্তী পর্বHaat-এর পুরো toolchain একসাথে।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৫০ · Parser-এর error recovery আর ভালো diagnostic messageআগের ভিত্তিPanic mode আর বার্তার নকশা।
- পর্ব ৫১ · Symbol table আর name resolution — scope-এর বাস্তবায়নআগের ভিত্তিGo-to-definition-এর কাঁচামাল।
- npm, Vite, ESLint আর Prettier — পেশাদার JavaScript-এর টুলবক্সপাশের ট্র্যাকLinter আর formatter ব্যবহারের দিক।
- Property-based testing — Hypothesis আর shrinkingপাশের ট্র্যাকFormatter-এর মতো property পরীক্ষার কৌশল।