Something went wrong. Try again.
source dump of claude code forked from oppi.li/claude-code
Something went wrong. Try again.
131 kB · 4436 lines
TypeScript
at main
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437/** * Pure-TypeScript bash parser producing tree-sitter-bash-compatible ASTs. * * Downstream code in parser.ts, ast.ts, prefix.ts, ParsedCommand.ts walks this * by field name. startIndex/endIndex are UTF-8 BYTE offsets (not JS string * indices). * * Grammar reference: tree-sitter-bash. Validated against a 3449-input golden * corpus generated from the WASM parser. */
export type TsNode = { type: string text: string startIndex: number endIndex: number children: TsNode[]}
type ParserModule = { parse: (source: string, timeoutMs?: number) => TsNode | null}
/** * 50ms wall-clock cap — bails out on pathological/adversarial input. * Pass `Infinity` via `parse(src, Infinity)` to disable (e.g. correctness * tests, where CI jitter would otherwise cause spurious null returns). */const PARSE_TIMEOUT_MS = 50
/** Node budget cap — bails out before OOM on deeply nested input. */const MAX_NODES = 50_000
const MODULE: ParserModule = { parse: parseSource }
const READY = Promise.resolve()
/** No-op: pure-TS parser needs no async init. Kept for API compatibility. */export function ensureParserInitialized(): Promise<void> { return READY}
/** Always succeeds — pure-TS needs no init. */export function getParserModule(): ParserModule | null { return MODULE}
// ───────────────────────────── Tokenizer ─────────────────────────────
type TokenType = | 'WORD' | 'NUMBER' | 'OP' | 'NEWLINE' | 'COMMENT' | 'DQUOTE' | 'SQUOTE' | 'ANSI_C' | 'DOLLAR' | 'DOLLAR_PAREN' | 'DOLLAR_BRACE' | 'DOLLAR_DPAREN' | 'BACKTICK' | 'LT_PAREN' | 'GT_PAREN' | 'EOF'
type Token = { type: TokenType value: string /** UTF-8 byte offset of first char */ start: number /** UTF-8 byte offset one past last char */ end: number}
const SPECIAL_VARS = new Set(['?', '$', '@', '*', '#', '-', '!', '_'])
const DECL_KEYWORDS = new Set([ 'export', 'declare', 'typeset', 'readonly', 'local',])
export const SHELL_KEYWORDS = new Set([ 'if', 'then', 'elif', 'else', 'fi', 'while', 'until', 'for', 'in', 'do', 'done', 'case', 'esac', 'function', 'select',])
/** * Lexer state. Tracks both JS-string index (for charAt) and UTF-8 byte offset * (for TsNode positions). ASCII fast path: byte == char index. Non-ASCII * advances byte count per-codepoint. */type Lexer = { src: string len: number /** JS string index */ i: number /** UTF-8 byte offset */ b: number /** Pending heredoc delimiters awaiting body scan at next newline */ heredocs: HeredocPending[] /** Precomputed byte offset for each char index (lazy for non-ASCII) */ byteTable: Uint32Array | null}
type HeredocPending = { delim: string stripTabs: boolean quoted: boolean /** Filled after body scan */ bodyStart: number bodyEnd: number endStart: number endEnd: number}
function makeLexer(src: string): Lexer { return { src, len: src.length, i: 0, b: 0, heredocs: [], byteTable: null, }}
/** Advance one JS char, updating byte offset for UTF-8. */function advance(L: Lexer): void { const c = L.src.charCodeAt(L.i) L.i++ if (c < 0x80) { L.b++ } else if (c < 0x800) { L.b += 2 } else if (c >= 0xd800 && c <= 0xdbff) { // High surrogate — next char completes the pair, total 4 UTF-8 bytes L.b += 4 L.i++ } else { L.b += 3 }}
function peek(L: Lexer, off = 0): string { return L.i + off < L.len ? L.src[L.i + off]! : ''}
function byteAt(L: Lexer, charIdx: number): number { // Fast path: ASCII-only prefix means char idx == byte idx if (L.byteTable) return L.byteTable[charIdx]! // Build table on first non-trivial lookup const t = new Uint32Array(L.len + 1) let b = 0 let i = 0 while (i < L.len) { t[i] = b const c = L.src.charCodeAt(i) if (c < 0x80) { b++ i++ } else if (c < 0x800) { b += 2 i++ } else if (c >= 0xd800 && c <= 0xdbff) { t[i + 1] = b + 2 b += 4 i += 2 } else { b += 3 i++ } } t[L.len] = b L.byteTable = t return t[charIdx]!}
function isWordChar(c: string): boolean { // Bash word chars: alphanumeric + various punctuation that doesn't start operators return ( (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '_' || c === '/' || c === '.' || c === '-' || c === '+' || c === ':' || c === '@' || c === '%' || c === ',' || c === '~' || c === '^' || c === '?' || c === '*' || c === '!' || c === '=' || c === '[' || c === ']' )}
function isWordStart(c: string): boolean { return isWordChar(c) || c === '\\'}
function isIdentStart(c: string): boolean { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '_'}
function isIdentChar(c: string): boolean { return isIdentStart(c) || (c >= '0' && c <= '9')}
function isDigit(c: string): boolean { return c >= '0' && c <= '9'}
function isHexDigit(c: string): boolean { return isDigit(c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')}
function isBaseDigit(c: string): boolean { // Bash BASE#DIGITS: digits, letters, @ and _ (up to base 64) return isIdentChar(c) || c === '@'}
/** * Unquoted heredoc delimiter chars. Bash accepts most non-metacharacters — * not just identifiers. Stop at whitespace, redirects, pipe/list operators, * and structural tokens. Allows !, -, ., +, etc. (e.g. <<!HEREDOC!). */function isHeredocDelimChar(c: string): boolean { return ( c !== '' && c !== ' ' && c !== '\t' && c !== '\n' && c !== '<' && c !== '>' && c !== '|' && c !== '&' && c !== ';' && c !== '(' && c !== ')' && c !== "'" && c !== '"' && c !== '`' && c !== '\\' )}
function skipBlanks(L: Lexer): void { while (L.i < L.len) { const c = L.src[L.i]! if (c === ' ' || c === '\t' || c === '\r') { // \r is whitespace per tree-sitter-bash extras /\s/ — handles CRLF inputs advance(L) } else if (c === '\\') { const nx = L.src[L.i + 1] if (nx === '\n' || (nx === '\r' && L.src[L.i + 2] === '\n')) { // Line continuation — tree-sitter extras: /\\\r?\n/ advance(L) advance(L) if (nx === '\r') advance(L) } else if (nx === ' ' || nx === '\t') { // \<space> or \<tab> — tree-sitter's _whitespace is /\\?[ \t\v]+/ advance(L) advance(L) } else { break } } else { break } }}
/** * Scan next token. Context-sensitive: `cmd` mode treats [ as operator (test * command start), `arg` mode treats [ as word char (glob/subscript). */function nextToken(L: Lexer, ctx: 'cmd' | 'arg' = 'arg'): Token { skipBlanks(L) const start = L.b if (L.i >= L.len) return { type: 'EOF', value: '', start, end: start }
const c = L.src[L.i]! const c1 = peek(L, 1) const c2 = peek(L, 2)
if (c === '\n') { advance(L) return { type: 'NEWLINE', value: '\n', start, end: L.b } }
if (c === '#') { const si = L.i while (L.i < L.len && L.src[L.i] !== '\n') advance(L) return { type: 'COMMENT', value: L.src.slice(si, L.i), start, end: L.b, } }
// Multi-char operators (longest match first) if (c === '&' && c1 === '&') { advance(L) advance(L) return { type: 'OP', value: '&&', start, end: L.b } } if (c === '|' && c1 === '|') { advance(L) advance(L) return { type: 'OP', value: '||', start, end: L.b } } if (c === '|' && c1 === '&') { advance(L) advance(L) return { type: 'OP', value: '|&', start, end: L.b } } if (c === ';' && c1 === ';' && c2 === '&') { advance(L) advance(L) advance(L) return { type: 'OP', value: ';;&', start, end: L.b } } if (c === ';' && c1 === ';') { advance(L) advance(L) return { type: 'OP', value: ';;', start, end: L.b } } if (c === ';' && c1 === '&') { advance(L) advance(L) return { type: 'OP', value: ';&', start, end: L.b } } if (c === '>' && c1 === '>') { advance(L) advance(L) return { type: 'OP', value: '>>', start, end: L.b } } if (c === '>' && c1 === '&' && c2 === '-') { advance(L) advance(L) advance(L) return { type: 'OP', value: '>&-', start, end: L.b } } if (c === '>' && c1 === '&') { advance(L) advance(L) return { type: 'OP', value: '>&', start, end: L.b } } if (c === '>' && c1 === '|') { advance(L) advance(L) return { type: 'OP', value: '>|', start, end: L.b } } if (c === '&' && c1 === '>' && c2 === '>') { advance(L) advance(L) advance(L) return { type: 'OP', value: '&>>', start, end: L.b } } if (c === '&' && c1 === '>') { advance(L) advance(L) return { type: 'OP', value: '&>', start, end: L.b } } if (c === '<' && c1 === '<' && c2 === '<') { advance(L) advance(L) advance(L) return { type: 'OP', value: '<<<', start, end: L.b } } if (c === '<' && c1 === '<' && c2 === '-') { advance(L) advance(L) advance(L) return { type: 'OP', value: '<<-', start, end: L.b } } if (c === '<' && c1 === '<') { advance(L) advance(L) return { type: 'OP', value: '<<', start, end: L.b } } if (c === '<' && c1 === '&' && c2 === '-') { advance(L) advance(L) advance(L) return { type: 'OP', value: '<&-', start, end: L.b } } if (c === '<' && c1 === '&') { advance(L) advance(L) return { type: 'OP', value: '<&', start, end: L.b } } if (c === '<' && c1 === '(') { advance(L) advance(L) return { type: 'LT_PAREN', value: '<(', start, end: L.b } } if (c === '>' && c1 === '(') { advance(L) advance(L) return { type: 'GT_PAREN', value: '>(', start, end: L.b } } if (c === '(' && c1 === '(') { advance(L) advance(L) return { type: 'OP', value: '((', start, end: L.b } } if (c === ')' && c1 === ')') { advance(L) advance(L) return { type: 'OP', value: '))', start, end: L.b } }
if (c === '|' || c === '&' || c === ';' || c === '>' || c === '<') { advance(L) return { type: 'OP', value: c, start, end: L.b } } if (c === '(' || c === ')') { advance(L) return { type: 'OP', value: c, start, end: L.b } }
// In cmd position, [ [[ { start test/group; in arg position they're word chars if (ctx === 'cmd') { if (c === '[' && c1 === '[') { advance(L) advance(L) return { type: 'OP', value: '[[', start, end: L.b } } if (c === '[') { advance(L) return { type: 'OP', value: '[', start, end: L.b } } if (c === '{' && (c1 === ' ' || c1 === '\t' || c1 === '\n')) { advance(L) return { type: 'OP', value: '{', start, end: L.b } } if (c === '}') { advance(L) return { type: 'OP', value: '}', start, end: L.b } } if (c === '!' && (c1 === ' ' || c1 === '\t')) { advance(L) return { type: 'OP', value: '!', start, end: L.b } } }
if (c === '"') { advance(L) return { type: 'DQUOTE', value: '"', start, end: L.b } } if (c === "'") { const si = L.i advance(L) while (L.i < L.len && L.src[L.i] !== "'") advance(L) if (L.i < L.len) advance(L) return { type: 'SQUOTE', value: L.src.slice(si, L.i), start, end: L.b, } }
if (c === '$') { if (c1 === '(' && c2 === '(') { advance(L) advance(L) advance(L) return { type: 'DOLLAR_DPAREN', value: '$((', start, end: L.b } } if (c1 === '(') { advance(L) advance(L) return { type: 'DOLLAR_PAREN', value: '$(', start, end: L.b } } if (c1 === '{') { advance(L) advance(L) return { type: 'DOLLAR_BRACE', value: '${', start, end: L.b } } if (c1 === "'") { // ANSI-C string $'...' const si = L.i advance(L) advance(L) while (L.i < L.len && L.src[L.i] !== "'") { if (L.src[L.i] === '\\' && L.i + 1 < L.len) advance(L) advance(L) } if (L.i < L.len) advance(L) return { type: 'ANSI_C', value: L.src.slice(si, L.i), start, end: L.b, } } advance(L) return { type: 'DOLLAR', value: '$', start, end: L.b } }
if (c === '`') { advance(L) return { type: 'BACKTICK', value: '`', start, end: L.b } }
// File descriptor before redirect: digit+ immediately followed by > or < if (isDigit(c)) { let j = L.i while (j < L.len && isDigit(L.src[j]!)) j++ const after = j < L.len ? L.src[j]! : '' if (after === '>' || after === '<') { const si = L.i while (L.i < j) advance(L) return { type: 'WORD', value: L.src.slice(si, L.i), start, end: L.b, } } }
// Word / number if (isWordStart(c) || c === '{' || c === '}') { const si = L.i while (L.i < L.len) { const ch = L.src[L.i]! if (ch === '\\') { if (L.i + 1 >= L.len) { // Trailing `\` at EOF — tree-sitter excludes it from the word and // emits a sibling ERROR. Stop here so the word ends before `\`. break } // Escape next char (including \n for line continuation mid-word) if (L.src[L.i + 1] === '\n') { advance(L) advance(L) continue } advance(L) advance(L) continue } if (!isWordChar(ch) && ch !== '{' && ch !== '}') { break } advance(L) } if (L.i > si) { const v = L.src.slice(si, L.i) // Number: optional sign then digits only if (/^-?\d+$/.test(v)) { return { type: 'NUMBER', value: v, start, end: L.b } } return { type: 'WORD', value: v, start, end: L.b } } // Empty word (lone `\` at EOF) — fall through to single-char consumer }
// Unknown char — consume as single-char word advance(L) return { type: 'WORD', value: c, start, end: L.b }}
// ───────────────────────────── Parser ─────────────────────────────
type ParseState = { L: Lexer src: string srcBytes: number /** True when byte offsets == char indices (no multi-byte UTF-8) */ isAscii: boolean nodeCount: number deadline: number aborted: boolean /** Depth of backtick nesting — inside `...`, ` terminates words */ inBacktick: number /** When set, parseSimpleCommand stops at this token (for `[` backtrack) */ stopToken: string | null}
function parseSource(source: string, timeoutMs?: number): TsNode | null { const L = makeLexer(source) const srcBytes = byteLengthUtf8(source) const P: ParseState = { L, src: source, srcBytes, isAscii: srcBytes === source.length, nodeCount: 0, deadline: performance.now() + (timeoutMs ?? PARSE_TIMEOUT_MS), aborted: false, inBacktick: 0, stopToken: null, } try { const program = parseProgram(P) if (P.aborted) return null return program } catch { return null }}
function byteLengthUtf8(s: string): number { let b = 0 for (let i = 0; i < s.length; i++) { const c = s.charCodeAt(i) if (c < 0x80) b++ else if (c < 0x800) b += 2 else if (c >= 0xd800 && c <= 0xdbff) { b += 4 i++ } else b += 3 } return b}
function checkBudget(P: ParseState): void { P.nodeCount++ if (P.nodeCount > MAX_NODES) { P.aborted = true throw new Error('budget') } if ((P.nodeCount & 0x7f) === 0 && performance.now() > P.deadline) { P.aborted = true throw new Error('timeout') }}
/** Build a node. Slices text from source by byte range via char-index lookup. */function mk( P: ParseState, type: string, start: number, end: number, children: TsNode[],): TsNode { checkBudget(P) return { type, text: sliceBytes(P, start, end), startIndex: start, endIndex: end, children, }}
function sliceBytes(P: ParseState, startByte: number, endByte: number): string { if (P.isAscii) return P.src.slice(startByte, endByte) // Find char indices for byte offsets. Build byte table if needed. const L = P.L if (!L.byteTable) byteAt(L, 0) const t = L.byteTable! // Binary search for char index where byte offset matches let lo = 0 let hi = P.src.length while (lo < hi) { const m = (lo + hi) >>> 1 if (t[m]! < startByte) lo = m + 1 else hi = m } const sc = lo lo = sc hi = P.src.length while (lo < hi) { const m = (lo + hi) >>> 1 if (t[m]! < endByte) lo = m + 1 else hi = m } return P.src.slice(sc, lo)}
function leaf(P: ParseState, type: string, tok: Token): TsNode { return mk(P, type, tok.start, tok.end, [])}
function parseProgram(P: ParseState): TsNode { const children: TsNode[] = [] // Skip leading whitespace & newlines — program start is first content byte skipBlanks(P.L) while (true) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'NEWLINE') { skipBlanks(P.L) continue } restoreLex(P.L, save) break } const progStart = P.L.b while (P.L.i < P.L.len) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'EOF') break if (t.type === 'NEWLINE') continue if (t.type === 'COMMENT') { children.push(leaf(P, 'comment', t)) continue } restoreLex(P.L, save) const stmts = parseStatements(P, null) for (const s of stmts) children.push(s) if (stmts.length === 0) { // Couldn't parse — emit ERROR and skip one token const errTok = nextToken(P.L, 'cmd') if (errTok.type === 'EOF') break // Stray `;;` at program level (e.g., `var=;;` outside case) — tree-sitter // silently elides. Keep leading `;` as ERROR (security: paste artifact). if ( errTok.type === 'OP' && errTok.value === ';;' && children.length > 0 ) { continue } children.push(mk(P, 'ERROR', errTok.start, errTok.end, [])) } } // tree-sitter includes trailing whitespace in program extent const progEnd = children.length > 0 ? P.srcBytes : progStart return mk(P, 'program', progStart, progEnd, children)}
/** Packed as (b << 16) | i — avoids heap alloc on every backtrack. */type LexSave = numberfunction saveLex(L: Lexer): LexSave { return L.b * 0x10000 + L.i}function restoreLex(L: Lexer, s: LexSave): void { L.i = s & 0xffff L.b = s >>> 16}
/** * Parse a sequence of statements separated by ; & newline. Returns a flat list * where ; and & are sibling leaves (NOT wrapped in 'list' — only && || get * that). Stops at terminator or EOF. */function parseStatements(P: ParseState, terminator: string | null): TsNode[] { const out: TsNode[] = [] while (true) { skipBlanks(P.L) const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'EOF') { restoreLex(P.L, save) break } if (t.type === 'NEWLINE') { // Process pending heredocs if (P.L.heredocs.length > 0) { scanHeredocBodies(P) } continue } if (t.type === 'COMMENT') { out.push(leaf(P, 'comment', t)) continue } if (terminator && t.type === 'OP' && t.value === terminator) { restoreLex(P.L, save) break } if ( t.type === 'OP' && (t.value === ')' || t.value === '}' || t.value === ';;' || t.value === ';&' || t.value === ';;&' || t.value === '))' || t.value === ']]' || t.value === ']') ) { restoreLex(P.L, save) break } if (t.type === 'BACKTICK' && P.inBacktick > 0) { restoreLex(P.L, save) break } if ( t.type === 'WORD' && (t.value === 'then' || t.value === 'elif' || t.value === 'else' || t.value === 'fi' || t.value === 'do' || t.value === 'done' || t.value === 'esac') ) { restoreLex(P.L, save) break } restoreLex(P.L, save) const stmt = parseAndOr(P) if (!stmt) break out.push(stmt) // Look for separator skipBlanks(P.L) const save2 = saveLex(P.L) const sep = nextToken(P.L, 'cmd') if (sep.type === 'OP' && (sep.value === ';' || sep.value === '&')) { // Check if terminator follows — if so, emit separator but stop const save3 = saveLex(P.L) const after = nextToken(P.L, 'cmd') restoreLex(P.L, save3) out.push(leaf(P, sep.value, sep)) if ( after.type === 'EOF' || (after.type === 'OP' && (after.value === ')' || after.value === '}' || after.value === ';;' || after.value === ';&' || after.value === ';;&')) || (after.type === 'WORD' && (after.value === 'then' || after.value === 'elif' || after.value === 'else' || after.value === 'fi' || after.value === 'do' || after.value === 'done' || after.value === 'esac')) ) { // Trailing separator — don't include it at program level unless // there's content after. But at inner levels we keep it. continue } } else if (sep.type === 'NEWLINE') { if (P.L.heredocs.length > 0) { scanHeredocBodies(P) } continue } else { restoreLex(P.L, save2) } } // Trim trailing separator if at program level return out}
/** * Parse pipeline chains joined by && ||. Left-associative nesting. * tree-sitter quirk: trailing redirect on the last pipeline wraps the ENTIRE * list in a redirected_statement — `a > x && b > y` becomes * redirected_statement(list(redirected_statement(a,>x), &&, b), >y). */function parseAndOr(P: ParseState): TsNode | null { let left = parsePipeline(P) if (!left) return null while (true) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'OP' && (t.value === '&&' || t.value === '||')) { const op = leaf(P, t.value, t) skipNewlines(P) const right = parsePipeline(P) if (!right) { left = mk(P, 'list', left.startIndex, op.endIndex, [left, op]) break } // If right is a redirected_statement, hoist its redirects to wrap the list. if (right.type === 'redirected_statement' && right.children.length >= 2) { const inner = right.children[0]! const redirs = right.children.slice(1) const listNode = mk(P, 'list', left.startIndex, inner.endIndex, [ left, op, inner, ]) const lastR = redirs[redirs.length - 1]! left = mk( P, 'redirected_statement', listNode.startIndex, lastR.endIndex, [listNode, ...redirs], ) } else { left = mk(P, 'list', left.startIndex, right.endIndex, [left, op, right]) } } else { restoreLex(P.L, save) break } } return left}
function skipNewlines(P: ParseState): void { while (true) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type !== 'NEWLINE') { restoreLex(P.L, save) break } }}
/** * Parse commands joined by | or |&. Flat children with operator leaves. * tree-sitter quirk: `a | b 2>nul | c` hoists the redirect on `b` to wrap * the preceding pipeline fragment — pipeline(redirected_statement( * pipeline(a,|,b), 2>nul), |, c). */function parsePipeline(P: ParseState): TsNode | null { let first = parseCommand(P) if (!first) return null const parts: TsNode[] = [first] while (true) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'OP' && (t.value === '|' || t.value === '|&')) { const op = leaf(P, t.value, t) skipNewlines(P) const next = parseCommand(P) if (!next) { parts.push(op) break } // Hoist trailing redirect on `next` to wrap current pipeline fragment if ( next.type === 'redirected_statement' && next.children.length >= 2 && parts.length >= 1 ) { const inner = next.children[0]! const redirs = next.children.slice(1) // Wrap existing parts + op + inner as a pipeline const pipeKids = [...parts, op, inner] const pipeNode = mk( P, 'pipeline', pipeKids[0]!.startIndex, inner.endIndex, pipeKids, ) const lastR = redirs[redirs.length - 1]! const wrapped = mk( P, 'redirected_statement', pipeNode.startIndex, lastR.endIndex, [pipeNode, ...redirs], ) parts.length = 0 parts.push(wrapped) first = wrapped continue } parts.push(op, next) } else { restoreLex(P.L, save) break } } if (parts.length === 1) return parts[0]! const last = parts[parts.length - 1]! return mk(P, 'pipeline', parts[0]!.startIndex, last.endIndex, parts)}
/** Parse a single command: simple, compound, or control structure. */function parseCommand(P: ParseState): TsNode | null { skipBlanks(P.L) const save = saveLex(P.L) const t = nextToken(P.L, 'cmd')
if (t.type === 'EOF') { restoreLex(P.L, save) return null }
// Negation — tree-sitter wraps just the command, redirects go outside. // `! cmd > out` → redirected_statement(negated_command(!, cmd), >out) if (t.type === 'OP' && t.value === '!') { const bang = leaf(P, '!', t) const inner = parseCommand(P) if (!inner) { restoreLex(P.L, save) return null } // If inner is a redirected_statement, hoist redirects outside negation if (inner.type === 'redirected_statement' && inner.children.length >= 2) { const cmd = inner.children[0]! const redirs = inner.children.slice(1) const neg = mk(P, 'negated_command', bang.startIndex, cmd.endIndex, [ bang, cmd, ]) const lastR = redirs[redirs.length - 1]! return mk(P, 'redirected_statement', neg.startIndex, lastR.endIndex, [ neg, ...redirs, ]) } return mk(P, 'negated_command', bang.startIndex, inner.endIndex, [ bang, inner, ]) }
if (t.type === 'OP' && t.value === '(') { const open = leaf(P, '(', t) const body = parseStatements(P, ')') const closeTok = nextToken(P.L, 'cmd') const close = closeTok.type === 'OP' && closeTok.value === ')' ? leaf(P, ')', closeTok) : mk(P, ')', open.endIndex, open.endIndex, []) const node = mk(P, 'subshell', open.startIndex, close.endIndex, [ open, ...body, close, ]) return maybeRedirect(P, node) }
if (t.type === 'OP' && t.value === '((') { const open = leaf(P, '((', t) const exprs = parseArithCommaList(P, '))', 'var') const closeTok = nextToken(P.L, 'cmd') const close = closeTok.value === '))' ? leaf(P, '))', closeTok) : mk(P, '))', open.endIndex, open.endIndex, []) return mk(P, 'compound_statement', open.startIndex, close.endIndex, [ open, ...exprs, close, ]) }
if (t.type === 'OP' && t.value === '{') { const open = leaf(P, '{', t) const body = parseStatements(P, '}') const closeTok = nextToken(P.L, 'cmd') const close = closeTok.type === 'OP' && closeTok.value === '}' ? leaf(P, '}', closeTok) : mk(P, '}', open.endIndex, open.endIndex, []) const node = mk(P, 'compound_statement', open.startIndex, close.endIndex, [ open, ...body, close, ]) return maybeRedirect(P, node) }
if (t.type === 'OP' && (t.value === '[' || t.value === '[[')) { const open = leaf(P, t.value, t) const closer = t.value === '[' ? ']' : ']]' // Grammar: `[` can contain choice(_expression, redirected_statement). // Try _expression first; if we don't reach `]`, backtrack and parse as // redirected_statement (handles `[ ! cmd -v go &>/dev/null ]`). const exprSave = saveLex(P.L) let expr = parseTestExpr(P, closer) skipBlanks(P.L) if (t.value === '[' && peek(P.L) !== ']') { // Expression parse didn't reach `]` — try as redirected_statement. // Thread `]` stop-token so parseSimpleCommand doesn't eat it as arg. restoreLex(P.L, exprSave) const prevStop = P.stopToken P.stopToken = ']' const rstmt = parseCommand(P) P.stopToken = prevStop if (rstmt && rstmt.type === 'redirected_statement') { expr = rstmt } else { // Neither worked — restore and keep the expression result restoreLex(P.L, exprSave) expr = parseTestExpr(P, closer) } skipBlanks(P.L) } const closeTok = nextToken(P.L, 'arg') let close: TsNode if (closeTok.value === closer) { close = leaf(P, closer, closeTok) } else { close = mk(P, closer, open.endIndex, open.endIndex, []) } const kids = expr ? [open, expr, close] : [open, close] return mk(P, 'test_command', open.startIndex, close.endIndex, kids) }
if (t.type === 'WORD') { if (t.value === 'if') return maybeRedirect(P, parseIf(P, t), true) if (t.value === 'while' || t.value === 'until') return maybeRedirect(P, parseWhile(P, t), true) if (t.value === 'for') return maybeRedirect(P, parseFor(P, t), true) if (t.value === 'select') return maybeRedirect(P, parseFor(P, t), true) if (t.value === 'case') return maybeRedirect(P, parseCase(P, t), true) if (t.value === 'function') return parseFunction(P, t) if (DECL_KEYWORDS.has(t.value)) return maybeRedirect(P, parseDeclaration(P, t)) if (t.value === 'unset' || t.value === 'unsetenv') { return maybeRedirect(P, parseUnset(P, t)) } }
restoreLex(P.L, save) return parseSimpleCommand(P)}
/** * Parse a simple command: [assignment]* word [arg|redirect]* * Returns variable_assignment if only one assignment and no command. */function parseSimpleCommand(P: ParseState): TsNode | null { const start = P.L.b const assignments: TsNode[] = [] const preRedirects: TsNode[] = []
while (true) { skipBlanks(P.L) const a = tryParseAssignment(P) if (a) { assignments.push(a) continue } const r = tryParseRedirect(P) if (r) { preRedirects.push(r) continue } break }
skipBlanks(P.L) const save = saveLex(P.L) const nameTok = nextToken(P.L, 'cmd') if ( nameTok.type === 'EOF' || nameTok.type === 'NEWLINE' || nameTok.type === 'COMMENT' || (nameTok.type === 'OP' && nameTok.value !== '{' && nameTok.value !== '[' && nameTok.value !== '[[') || (nameTok.type === 'WORD' && SHELL_KEYWORDS.has(nameTok.value) && nameTok.value !== 'in') ) { restoreLex(P.L, save) // No command — standalone assignment(s) or redirect if (assignments.length === 1 && preRedirects.length === 0) { return assignments[0]! } if (preRedirects.length > 0 && assignments.length === 0) { // Bare redirect → redirected_statement with just file_redirect children const last = preRedirects[preRedirects.length - 1]! return mk( P, 'redirected_statement', preRedirects[0]!.startIndex, last.endIndex, preRedirects, ) } if (assignments.length > 1 && preRedirects.length === 0) { // `A=1 B=2` with no command → variable_assignments (plural) const last = assignments[assignments.length - 1]! return mk( P, 'variable_assignments', assignments[0]!.startIndex, last.endIndex, assignments, ) } if (assignments.length > 0 || preRedirects.length > 0) { const all = [...assignments, ...preRedirects] const last = all[all.length - 1]! return mk(P, 'command', start, last.endIndex, all) } return null } restoreLex(P.L, save)
// Check for function definition: name() { ... } const fnSave = saveLex(P.L) const nm = parseWord(P, 'cmd') if (nm && nm.type === 'word') { skipBlanks(P.L) if (peek(P.L) === '(' && peek(P.L, 1) === ')') { const oTok = nextToken(P.L, 'cmd') const cTok = nextToken(P.L, 'cmd') const oParen = leaf(P, '(', oTok) const cParen = leaf(P, ')', cTok) skipBlanks(P.L) skipNewlines(P) const body = parseCommand(P) if (body) { // If body is redirected_statement(compound_statement, file_redirect...), // hoist redirects to function_definition level per tree-sitter grammar let bodyKids: TsNode[] = [body] if ( body.type === 'redirected_statement' && body.children.length >= 2 && body.children[0]!.type === 'compound_statement' ) { bodyKids = body.children } const last = bodyKids[bodyKids.length - 1]! return mk(P, 'function_definition', nm.startIndex, last.endIndex, [ nm, oParen, cParen, ...bodyKids, ]) } } } restoreLex(P.L, fnSave)
const nameArg = parseWord(P, 'cmd') if (!nameArg) { if (assignments.length === 1) return assignments[0]! return null }
const cmdName = mk(P, 'command_name', nameArg.startIndex, nameArg.endIndex, [ nameArg, ])
const args: TsNode[] = [] const redirects: TsNode[] = [] let heredocRedirect: TsNode | null = null
while (true) { skipBlanks(P.L) // Post-command redirects are greedy (repeat1 $._literal) — once a redirect // appears after command_name, subsequent literals attach to it per grammar's // prec.left. `grep 2>/dev/null -q foo` → file_redirect eats `-q foo`. // Args parsed BEFORE the first redirect still go to command (cat a b > out). const r = tryParseRedirect(P, true) if (r) { if (r.type === 'heredoc_redirect') { heredocRedirect = r } else if (r.type === 'herestring_redirect') { args.push(r) } else { redirects.push(r) } continue } // Once a file_redirect has been seen, command args are done — grammar's // command rule doesn't allow file_redirect in its post-name choice, so // anything after belongs to redirected_statement's file_redirect children. if (redirects.length > 0) break // `[` test_command backtrack — stop at `]` so outer handler can consume it if (P.stopToken === ']' && peek(P.L) === ']') break const save2 = saveLex(P.L) const pk = nextToken(P.L, 'arg') if ( pk.type === 'EOF' || pk.type === 'NEWLINE' || pk.type === 'COMMENT' || (pk.type === 'OP' && (pk.value === '|' || pk.value === '|&' || pk.value === '&&' || pk.value === '||' || pk.value === ';' || pk.value === ';;' || pk.value === ';&' || pk.value === ';;&' || pk.value === '&' || pk.value === ')' || pk.value === '}' || pk.value === '))')) ) { restoreLex(P.L, save2) break } restoreLex(P.L, save2) const arg = parseWord(P, 'arg') if (!arg) { // Lone `(` in arg position — tree-sitter parses this as subshell arg // e.g., `echo =(cmd)` → command has ERROR(=), subshell(cmd) as args if (peek(P.L) === '(') { const oTok = nextToken(P.L, 'cmd') const open = leaf(P, '(', oTok) const body = parseStatements(P, ')') const cTok = nextToken(P.L, 'cmd') const close = cTok.type === 'OP' && cTok.value === ')' ? leaf(P, ')', cTok) : mk(P, ')', open.endIndex, open.endIndex, []) args.push( mk(P, 'subshell', open.startIndex, close.endIndex, [ open, ...body, close, ]), ) continue } break } // Lone `=` in arg position is a parse error in bash — tree-sitter wraps // it in ERROR for recovery. Happens in `echo =(cmd)` (zsh process-sub). if (arg.type === 'word' && arg.text === '=') { args.push(mk(P, 'ERROR', arg.startIndex, arg.endIndex, [arg])) continue } // Word immediately followed by `(` (no whitespace) is a parse error — // bash doesn't allow glob-then-subshell adjacency. tree-sitter wraps the // word in ERROR. Catches zsh glob qualifiers like `*.(e:'cmd':)`. if ( (arg.type === 'word' || arg.type === 'concatenation') && peek(P.L) === '(' && P.L.b === arg.endIndex ) { args.push(mk(P, 'ERROR', arg.startIndex, arg.endIndex, [arg])) continue } args.push(arg) }
// preRedirects (e.g., `2>&1 cat`, `<<<str cmd`) go INSIDE the command node // before command_name per tree-sitter grammar, not in redirected_statement const cmdChildren = [...assignments, ...preRedirects, cmdName, ...args] const cmdEnd = cmdChildren.length > 0 ? cmdChildren[cmdChildren.length - 1]!.endIndex : cmdName.endIndex const cmdStart = cmdChildren[0]!.startIndex const cmd = mk(P, 'command', cmdStart, cmdEnd, cmdChildren)
if (heredocRedirect) { // Scan heredoc body now scanHeredocBodies(P) const hd = P.L.heredocs.shift() if (hd && heredocRedirect.children.length >= 2) { const bodyNode = mk( P, 'heredoc_body', hd.bodyStart, hd.bodyEnd, hd.quoted ? [] : parseHeredocBodyContent(P, hd.bodyStart, hd.bodyEnd), ) const endNode = mk(P, 'heredoc_end', hd.endStart, hd.endEnd, []) heredocRedirect.children.push(bodyNode, endNode) heredocRedirect.endIndex = hd.endEnd heredocRedirect.text = sliceBytes( P, heredocRedirect.startIndex, hd.endEnd, ) } const allR = [...preRedirects, heredocRedirect, ...redirects] const rStart = preRedirects.length > 0 ? Math.min(cmd.startIndex, preRedirects[0]!.startIndex) : cmd.startIndex return mk(P, 'redirected_statement', rStart, heredocRedirect.endIndex, [ cmd, ...allR, ]) }
if (redirects.length > 0) { const last = redirects[redirects.length - 1]! return mk(P, 'redirected_statement', cmd.startIndex, last.endIndex, [ cmd, ...redirects, ]) }
return cmd}
function maybeRedirect( P: ParseState, node: TsNode, allowHerestring = false,): TsNode { const redirects: TsNode[] = [] while (true) { skipBlanks(P.L) const save = saveLex(P.L) const r = tryParseRedirect(P) if (!r) break if (r.type === 'herestring_redirect' && !allowHerestring) { restoreLex(P.L, save) break } redirects.push(r) } if (redirects.length === 0) return node const last = redirects[redirects.length - 1]! return mk(P, 'redirected_statement', node.startIndex, last.endIndex, [ node, ...redirects, ])}
function tryParseAssignment(P: ParseState): TsNode | null { const save = saveLex(P.L) skipBlanks(P.L) const startB = P.L.b // Must start with identifier if (!isIdentStart(peek(P.L))) { restoreLex(P.L, save) return null } while (isIdentChar(peek(P.L))) advance(P.L) const nameEnd = P.L.b // Optional subscript let subEnd = nameEnd if (peek(P.L) === '[') { advance(P.L) let depth = 1 while (P.L.i < P.L.len && depth > 0) { const c = peek(P.L) if (c === '[') depth++ else if (c === ']') depth-- advance(P.L) } subEnd = P.L.b } const c = peek(P.L) const c1 = peek(P.L, 1) let op: string if (c === '=' && c1 !== '=') { op = '=' } else if (c === '+' && c1 === '=') { op = '+=' } else { restoreLex(P.L, save) return null } const nameNode = mk(P, 'variable_name', startB, nameEnd, []) // Subscript handling: wrap in subscript node if present let lhs: TsNode = nameNode if (subEnd > nameEnd) { const brOpen = mk(P, '[', nameEnd, nameEnd + 1, []) const idx = parseSubscriptIndex(P, nameEnd + 1, subEnd - 1) const brClose = mk(P, ']', subEnd - 1, subEnd, []) lhs = mk(P, 'subscript', startB, subEnd, [nameNode, brOpen, idx, brClose]) } const opStart = P.L.b advance(P.L) if (op === '+=') advance(P.L) const opEnd = P.L.b const opNode = mk(P, op, opStart, opEnd, []) let val: TsNode | null = null if (peek(P.L) === '(') { // Array const aoTok = nextToken(P.L, 'cmd') const aOpen = leaf(P, '(', aoTok) const elems: TsNode[] = [aOpen] while (true) { skipBlanks(P.L) if (peek(P.L) === ')') break const e = parseWord(P, 'arg') if (!e) break elems.push(e) } const acTok = nextToken(P.L, 'cmd') const aClose = acTok.value === ')' ? leaf(P, ')', acTok) : mk(P, ')', aOpen.endIndex, aOpen.endIndex, []) elems.push(aClose) val = mk(P, 'array', aOpen.startIndex, aClose.endIndex, elems) } else { const c2 = peek(P.L) if ( c2 && c2 !== ' ' && c2 !== '\t' && c2 !== '\n' && c2 !== ';' && c2 !== '&' && c2 !== '|' && c2 !== ')' && c2 !== '}' ) { val = parseWord(P, 'arg') } } const kids = val ? [lhs, opNode, val] : [lhs, opNode] const end = val ? val.endIndex : opEnd return mk(P, 'variable_assignment', startB, end, kids)}
/** * Parse subscript index content. Parsed arithmetically per tree-sitter grammar: * `${a[1+2]}` → binary_expression; `${a[++i]}` → unary_expression(word); * `${a[(($n+1))]}` → compound_statement(binary_expression). Falls back to * simple patterns (@, *) as word. */function parseSubscriptIndexInline(P: ParseState): TsNode | null { skipBlanks(P.L) const c = peek(P.L) // @ or * alone → word (associative array all-keys) if ((c === '@' || c === '*') && peek(P.L, 1) === ']') { const s = P.L.b advance(P.L) return mk(P, 'word', s, P.L.b, []) } // ((expr)) → compound_statement wrapping the inner arithmetic if (c === '(' && peek(P.L, 1) === '(') { const oStart = P.L.b advance(P.L) advance(P.L) const open = mk(P, '((', oStart, P.L.b, []) const inner = parseArithExpr(P, '))', 'var') skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')' && peek(P.L, 1) === ')') { const cs = P.L.b advance(P.L) advance(P.L) close = mk(P, '))', cs, P.L.b, []) } else { close = mk(P, '))', P.L.b, P.L.b, []) } const kids = inner ? [open, inner, close] : [open, close] return mk(P, 'compound_statement', open.startIndex, close.endIndex, kids) } // Arithmetic — but bare identifiers in subscript use 'word' mode per // tree-sitter (${words[++counter]} → unary_expression(word)). return parseArithExpr(P, ']', 'word')}
/** Legacy byte-range subscript index parser — kept for callers that pre-scan. */function parseSubscriptIndex( P: ParseState, startB: number, endB: number,): TsNode { const text = sliceBytes(P, startB, endB) if (/^\d+$/.test(text)) return mk(P, 'number', startB, endB, []) const m = /^\$([a-zA-Z_]\w*)$/.exec(text) if (m) { const dollar = mk(P, '$', startB, startB + 1, []) const vn = mk(P, 'variable_name', startB + 1, endB, []) return mk(P, 'simple_expansion', startB, endB, [dollar, vn]) } if (text.length === 2 && text[0] === '$' && SPECIAL_VARS.has(text[1]!)) { const dollar = mk(P, '$', startB, startB + 1, []) const vn = mk(P, 'special_variable_name', startB + 1, endB, []) return mk(P, 'simple_expansion', startB, endB, [dollar, vn]) } return mk(P, 'word', startB, endB, [])}
/** * Can the current position start a redirect destination literal? * Returns false at redirect ops, terminators, or file-descriptor-prefixed ops * so file_redirect's repeat1($._literal) stops at the right boundary. */function isRedirectLiteralStart(P: ParseState): boolean { const c = peek(P.L) if (c === '' || c === '\n') return false // Shell terminators and operators if (c === '|' || c === '&' || c === ';' || c === '(' || c === ')') return false // Redirect operators (< > with any suffix; <( >( handled by caller) if (c === '<' || c === '>') { // <( >( are process substitutions — those ARE literals return peek(P.L, 1) === '(' } // N< N> file descriptor prefix — starts a new redirect, not a literal if (isDigit(c)) { let j = P.L.i while (j < P.L.len && isDigit(P.L.src[j]!)) j++ const after = j < P.L.len ? P.L.src[j]! : '' if (after === '>' || after === '<') return false } // `}` only terminates if we're in a context where it's a closer — but // file_redirect sees `}` as word char (e.g., `>$HOME}` is valid path char). // Actually `}` at top level terminates compound_statement — need to stop. if (c === '}') return false // Test command closer — when parseSimpleCommand is called from `[` context, // `]` must terminate so parseCommand can return and `[` handler consume it. if (P.stopToken === ']' && c === ']') return false return true}
/** * Parse a redirect operator + destination(s). * @param greedy When true, file_redirect consumes repeat1($._literal) per * grammar's prec.left — `cmd >f a b c` attaches `a b c` to the redirect. * When false (preRedirect context), takes only 1 destination because * command's dynamic precedence beats redirected_statement's prec(-1). */function tryParseRedirect(P: ParseState, greedy = false): TsNode | null { const save = saveLex(P.L) skipBlanks(P.L) // File descriptor prefix? let fd: TsNode | null = null if (isDigit(peek(P.L))) { const startB = P.L.b let j = P.L.i while (j < P.L.len && isDigit(P.L.src[j]!)) j++ const after = j < P.L.len ? P.L.src[j]! : '' if (after === '>' || after === '<') { while (P.L.i < j) advance(P.L) fd = mk(P, 'file_descriptor', startB, P.L.b, []) } } const t = nextToken(P.L, 'arg') if (t.type !== 'OP') { restoreLex(P.L, save) return null } const v = t.value if (v === '<<<') { const op = leaf(P, '<<<', t) skipBlanks(P.L) const target = parseWord(P, 'arg') const end = target ? target.endIndex : op.endIndex const kids = target ? [op, target] : [op] return mk( P, 'herestring_redirect', fd ? fd.startIndex : op.startIndex, end, fd ? [fd, ...kids] : kids, ) } if (v === '<<' || v === '<<-') { const op = leaf(P, v, t) // Heredoc start — delimiter word (may be quoted) skipBlanks(P.L) const dStart = P.L.b let quoted = false let delim = '' const dc = peek(P.L) if (dc === "'" || dc === '"') { quoted = true advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== dc) { delim += peek(P.L) advance(P.L) } if (P.L.i < P.L.len) advance(P.L) } else if (dc === '\\') { // Backslash-escaped delimiter: \X — exactly one escaped char, body is // quoted (literal). Covers <<\EOF <<\' <<\\ etc. quoted = true advance(P.L) if (P.L.i < P.L.len && peek(P.L) !== '\n') { delim += peek(P.L) advance(P.L) } // May be followed by more ident chars (e.g. <<\EOF → delim "EOF") while (P.L.i < P.L.len && isIdentChar(peek(P.L))) { delim += peek(P.L) advance(P.L) } } else { // Unquoted delimiter: bash accepts most non-metacharacters (not just // identifiers). Allow !, -, ., etc. — stop at shell metachars. while (P.L.i < P.L.len && isHeredocDelimChar(peek(P.L))) { delim += peek(P.L) advance(P.L) } } const dEnd = P.L.b const startNode = mk(P, 'heredoc_start', dStart, dEnd, []) // Register pending heredoc — body scanned at next newline P.L.heredocs.push({ delim, stripTabs: v === '<<-', quoted, bodyStart: 0, bodyEnd: 0, endStart: 0, endEnd: 0, }) const kids = fd ? [fd, op, startNode] : [op, startNode] const startIdx = fd ? fd.startIndex : op.startIndex // SECURITY: tree-sitter nests any pipeline/list/file_redirect appearing // between heredoc_start and the newline as a CHILD of heredoc_redirect. // `ls <<'EOF' | rm -rf /tmp/evil` must not silently drop the rm. Parse // trailing words and file_redirects properly (ast.ts walkHeredocRedirect // fails closed on any unrecognized child via tooComplex). Pipeline / list // operators (| && || ;) are structurally complex — emit ERROR so the same // fail-closed path rejects them. while (true) { skipBlanks(P.L) const tc = peek(P.L) if (tc === '\n' || tc === '' || P.L.i >= P.L.len) break // File redirect after delimiter: cat <<EOF > out.txt if (tc === '>' || tc === '<' || isDigit(tc)) { const rSave = saveLex(P.L) const r = tryParseRedirect(P) if (r && r.type === 'file_redirect') { kids.push(r) continue } restoreLex(P.L, rSave) } // Pipeline after heredoc_start: `one <<EOF | grep two` — tree-sitter // nests the pipeline as a child of heredoc_redirect. ast.ts // walkHeredocRedirect fails closed on pipeline/command via tooComplex. if (tc === '|' && peek(P.L, 1) !== '|') { advance(P.L) skipBlanks(P.L) const pipeCmds: TsNode[] = [] while (true) { const cmd = parseCommand(P) if (!cmd) break pipeCmds.push(cmd) skipBlanks(P.L) if (peek(P.L) === '|' && peek(P.L, 1) !== '|') { const ps = P.L.b advance(P.L) pipeCmds.push(mk(P, '|', ps, P.L.b, [])) skipBlanks(P.L) continue } break } if (pipeCmds.length > 0) { const pl = pipeCmds[pipeCmds.length - 1]! // tree-sitter always wraps in pipeline after `|`, even single command kids.push( mk(P, 'pipeline', pipeCmds[0]!.startIndex, pl.endIndex, pipeCmds), ) } continue } // && / || after heredoc_start: `cat <<-EOF || die "..."` — tree-sitter // nests just the RHS command (not a list) as a child of heredoc_redirect. if ( (tc === '&' && peek(P.L, 1) === '&') || (tc === '|' && peek(P.L, 1) === '|') ) { advance(P.L) advance(P.L) skipBlanks(P.L) const rhs = parseCommand(P) if (rhs) kids.push(rhs) continue } // Terminator / unhandled metachar — consume rest of line as ERROR so // ast.ts rejects it. Covers ; & ( ) if (tc === '&' || tc === ';' || tc === '(' || tc === ')') { const eStart = P.L.b while (P.L.i < P.L.len && peek(P.L) !== '\n') advance(P.L) kids.push(mk(P, 'ERROR', eStart, P.L.b, [])) break } // Trailing word argument: newins <<-EOF - org.freedesktop.service const w = parseWord(P, 'arg') if (w) { kids.push(w) continue } // Unrecognized — consume rest of line as ERROR const eStart = P.L.b while (P.L.i < P.L.len && peek(P.L) !== '\n') advance(P.L) if (P.L.b > eStart) kids.push(mk(P, 'ERROR', eStart, P.L.b, [])) break } return mk(P, 'heredoc_redirect', startIdx, P.L.b, kids) } // Close-fd variants: `<&-` `>&-` have OPTIONAL destination (0 or 1) if (v === '<&-' || v === '>&-') { const op = leaf(P, v, t) const kids: TsNode[] = [] if (fd) kids.push(fd) kids.push(op) // Optional single destination — only consume if next is a literal skipBlanks(P.L) const dSave = saveLex(P.L) const dest = isRedirectLiteralStart(P) ? parseWord(P, 'arg') : null if (dest) { kids.push(dest) } else { restoreLex(P.L, dSave) } const startIdx = fd ? fd.startIndex : op.startIndex const end = dest ? dest.endIndex : op.endIndex return mk(P, 'file_redirect', startIdx, end, kids) } if ( v === '>' || v === '>>' || v === '>&' || v === '>|' || v === '&>' || v === '&>>' || v === '<' || v === '<&' ) { const op = leaf(P, v, t) const kids: TsNode[] = [] if (fd) kids.push(fd) kids.push(op) // Grammar: destination is repeat1($._literal) — greedily consume literals // until a non-literal (redirect op, terminator, etc). tree-sitter's // prec.left makes `cmd >f a b c` attach `a b c` to the file_redirect, // NOT to the command. Structural quirk but required for corpus parity. // In preRedirect context (greedy=false), take only 1 literal because // command's dynamic precedence beats redirected_statement's prec(-1). let end = op.endIndex let taken = 0 while (true) { skipBlanks(P.L) if (!isRedirectLiteralStart(P)) break if (!greedy && taken >= 1) break const tc = peek(P.L) const tc1 = peek(P.L, 1) let target: TsNode | null = null if ((tc === '<' || tc === '>') && tc1 === '(') { target = parseProcessSub(P) } else { target = parseWord(P, 'arg') } if (!target) break kids.push(target) end = target.endIndex taken++ } const startIdx = fd ? fd.startIndex : op.startIndex return mk(P, 'file_redirect', startIdx, end, kids) } restoreLex(P.L, save) return null}
function parseProcessSub(P: ParseState): TsNode | null { const c = peek(P.L) if ((c !== '<' && c !== '>') || peek(P.L, 1) !== '(') return null const start = P.L.b advance(P.L) advance(P.L) const open = mk(P, c + '(', start, P.L.b, []) const body = parseStatements(P, ')') skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')') { const cs = P.L.b advance(P.L) close = mk(P, ')', cs, P.L.b, []) } else { close = mk(P, ')', P.L.b, P.L.b, []) } return mk(P, 'process_substitution', start, close.endIndex, [ open, ...body, close, ])}
function scanHeredocBodies(P: ParseState): void { // Skip to newline if not already there while (P.L.i < P.L.len && P.L.src[P.L.i] !== '\n') advance(P.L) if (P.L.i < P.L.len) advance(P.L) for (const hd of P.L.heredocs) { hd.bodyStart = P.L.b const delimLen = hd.delim.length while (P.L.i < P.L.len) { const lineStart = P.L.i const lineStartB = P.L.b // Skip leading tabs if <<- let checkI = lineStart if (hd.stripTabs) { while (checkI < P.L.len && P.L.src[checkI] === '\t') checkI++ } // Check if this line is the delimiter if ( P.L.src.startsWith(hd.delim, checkI) && (checkI + delimLen >= P.L.len || P.L.src[checkI + delimLen] === '\n' || P.L.src[checkI + delimLen] === '\r') ) { hd.bodyEnd = lineStartB // Advance past tabs while (P.L.i < checkI) advance(P.L) hd.endStart = P.L.b // Advance past delimiter for (let k = 0; k < delimLen; k++) advance(P.L) hd.endEnd = P.L.b // Skip trailing newline if (P.L.i < P.L.len && P.L.src[P.L.i] === '\n') advance(P.L) return } // Consume line while (P.L.i < P.L.len && P.L.src[P.L.i] !== '\n') advance(P.L) if (P.L.i < P.L.len) advance(P.L) } // Unterminated hd.bodyEnd = P.L.b hd.endStart = P.L.b hd.endEnd = P.L.b }}
function parseHeredocBodyContent( P: ParseState, start: number, end: number,): TsNode[] { // Parse expansions inside an unquoted heredoc body. const saved = saveLex(P.L) // Position lexer at body start restoreLexToByte(P, start) const out: TsNode[] = [] let contentStart = P.L.b // tree-sitter-bash's heredoc_body rule hides the initial text segment // (_heredoc_body_beginning) — only content AFTER the first expansion is // emitted as heredoc_content. Track whether we've seen an expansion yet. let sawExpansion = false while (P.L.b < end) { const c = peek(P.L) // Backslash escapes suppress expansion: \$ \` stay literal in heredoc. if (c === '\\') { const nxt = peek(P.L, 1) if (nxt === '$' || nxt === '`' || nxt === '\\') { advance(P.L) advance(P.L) continue } advance(P.L) continue } if (c === '$' || c === '`') { const preB = P.L.b const exp = parseDollarLike(P) // Bare `$` followed by non-name (e.g. `$'` in a regex) returns a lone // '$' leaf, not an expansion — treat as literal content, don't split. if ( exp && (exp.type === 'simple_expansion' || exp.type === 'expansion' || exp.type === 'command_substitution' || exp.type === 'arithmetic_expansion') ) { if (sawExpansion && preB > contentStart) { out.push(mk(P, 'heredoc_content', contentStart, preB, [])) } out.push(exp) contentStart = P.L.b sawExpansion = true } continue } advance(P.L) } // Only emit heredoc_content children if there were expansions — otherwise // the heredoc_body is a leaf node (tree-sitter convention). if (sawExpansion) { out.push(mk(P, 'heredoc_content', contentStart, end, [])) } restoreLex(P.L, saved) return out}
function restoreLexToByte(P: ParseState, targetByte: number): void { if (!P.L.byteTable) byteAt(P.L, 0) const t = P.L.byteTable! let lo = 0 let hi = P.src.length while (lo < hi) { const m = (lo + hi) >>> 1 if (t[m]! < targetByte) lo = m + 1 else hi = m } P.L.i = lo P.L.b = targetByte}
/** * Parse a word-position element: bare word, string, expansion, or concatenation * thereof. Returns a single node; if multiple adjacent fragments, wraps in * concatenation. */function parseWord(P: ParseState, _ctx: 'cmd' | 'arg'): TsNode | null { skipBlanks(P.L) const parts: TsNode[] = [] while (P.L.i < P.L.len) { const c = peek(P.L) if ( c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '' || c === '|' || c === '&' || c === ';' || c === '(' || c === ')' ) { break } // < > are redirect operators unless <( >( (process substitution) if (c === '<' || c === '>') { if (peek(P.L, 1) === '(') { const ps = parseProcessSub(P) if (ps) parts.push(ps) continue } break } if (c === '"') { parts.push(parseDoubleQuoted(P)) continue } if (c === "'") { const tok = nextToken(P.L, 'arg') parts.push(leaf(P, 'raw_string', tok)) continue } if (c === '$') { const c1 = peek(P.L, 1) if (c1 === "'") { const tok = nextToken(P.L, 'arg') parts.push(leaf(P, 'ansi_c_string', tok)) continue } if (c1 === '"') { // Translated string: emit $ leaf + string node const dTok: Token = { type: 'DOLLAR', value: '$', start: P.L.b, end: P.L.b + 1, } advance(P.L) parts.push(leaf(P, '$', dTok)) parts.push(parseDoubleQuoted(P)) continue } if (c1 === '`') { // `$` followed by backtick — tree-sitter elides the $ entirely // and emits just (command_substitution). Consume $ and let next // iteration handle the backtick. advance(P.L) continue } const exp = parseDollarLike(P) if (exp) parts.push(exp) continue } if (c === '`') { if (P.inBacktick > 0) break const bt = parseBacktick(P) if (bt) parts.push(bt) continue } // Brace expression {1..5} or {a,b,c} — only if looks like one if (c === '{') { const be = tryParseBraceExpr(P) if (be) { parts.push(be) continue } // SECURITY: if `{` is immediately followed by a command terminator // (; | & newline or EOF), it's a standalone word — don't slurp the // rest of the line via tryParseBraceLikeCat. `echo {;touch /tmp/evil` // must split on `;` so the security walker sees `touch`. const nc = peek(P.L, 1) if ( nc === ';' || nc === '|' || nc === '&' || nc === '\n' || nc === '' || nc === ')' || nc === ' ' || nc === '\t' ) { const bStart = P.L.b advance(P.L) parts.push(mk(P, 'word', bStart, P.L.b, [])) continue } // Otherwise treat { and } as word fragments const cat = tryParseBraceLikeCat(P) if (cat) { for (const p of cat) parts.push(p) continue } } // Standalone `}` in arg position is a word (e.g., `echo }foo`). // parseBareWord breaks on `}` so handle it here. if (c === '}') { const bStart = P.L.b advance(P.L) parts.push(mk(P, 'word', bStart, P.L.b, [])) continue } // `[` and `]` are single-char word fragments (tree-sitter splits at // brackets: `[:lower:]` → `[` `:lower:` `]`, `{o[k]}` → 6 words). if (c === '[' || c === ']') { const bStart = P.L.b advance(P.L) parts.push(mk(P, 'word', bStart, P.L.b, [])) continue } // Bare word fragment const frag = parseBareWord(P) if (!frag) break // `NN#${...}` or `NN#$(...)` → (number (expansion|command_substitution)). // Grammar: number can be seq(/-?(0x)?[0-9]+#/, choice(expansion, cmd_sub)). // `10#${cmd}` must NOT be concatenation — it's a single number node with // the expansion as child. Detect here: frag ends with `#`, next is $ {/(. if ( frag.type === 'word' && /^-?(0x)?[0-9]+#$/.test(frag.text) && peek(P.L) === '$' && (peek(P.L, 1) === '{' || peek(P.L, 1) === '(') ) { const exp = parseDollarLike(P) if (exp) { // Prefix `NN#` is an anonymous pattern in grammar — only the // expansion/cmd_sub is a named child. parts.push(mk(P, 'number', frag.startIndex, exp.endIndex, [exp])) continue } } parts.push(frag) } if (parts.length === 0) return null if (parts.length === 1) return parts[0]! // Concatenation const first = parts[0]! const last = parts[parts.length - 1]! return mk(P, 'concatenation', first.startIndex, last.endIndex, parts)}
function parseBareWord(P: ParseState): TsNode | null { const start = P.L.b const startI = P.L.i while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\\') { if (P.L.i + 1 >= P.L.len) { // Trailing unpaired `\` at true EOF — tree-sitter emits word WITHOUT // the `\` plus a sibling ERROR node. Stop here; caller emits ERROR. break } const nx = P.L.src[P.L.i + 1] if (nx === '\n' || (nx === '\r' && P.L.src[P.L.i + 2] === '\n')) { // Line continuation BREAKS the word (tree-sitter quirk) — handles \r?\n break } advance(P.L) advance(P.L) continue } if ( c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '' || c === '|' || c === '&' || c === ';' || c === '(' || c === ')' || c === '<' || c === '>' || c === '"' || c === "'" || c === '$' || c === '`' || c === '{' || c === '}' || c === '[' || c === ']' ) { break } advance(P.L) } if (P.L.b === start) return null const text = P.src.slice(startI, P.L.i) const type = /^-?\d+$/.test(text) ? 'number' : 'word' return mk(P, type, start, P.L.b, [])}
function tryParseBraceExpr(P: ParseState): TsNode | null { // {N..M} where N, M are numbers or single chars const save = saveLex(P.L) if (peek(P.L) !== '{') return null const oStart = P.L.b advance(P.L) const oEnd = P.L.b // First part const p1Start = P.L.b while (isDigit(peek(P.L)) || isIdentStart(peek(P.L))) advance(P.L) const p1End = P.L.b if (p1End === p1Start || peek(P.L) !== '.' || peek(P.L, 1) !== '.') { restoreLex(P.L, save) return null } const dotStart = P.L.b advance(P.L) advance(P.L) const dotEnd = P.L.b const p2Start = P.L.b while (isDigit(peek(P.L)) || isIdentStart(peek(P.L))) advance(P.L) const p2End = P.L.b if (p2End === p2Start || peek(P.L) !== '}') { restoreLex(P.L, save) return null } const cStart = P.L.b advance(P.L) const cEnd = P.L.b const p1Text = sliceBytes(P, p1Start, p1End) const p2Text = sliceBytes(P, p2Start, p2End) const p1IsNum = /^\d+$/.test(p1Text) const p2IsNum = /^\d+$/.test(p2Text) // Valid brace expression: both numbers OR both single chars. Mixed = reject. if (p1IsNum !== p2IsNum) { restoreLex(P.L, save) return null } if (!p1IsNum && (p1Text.length !== 1 || p2Text.length !== 1)) { restoreLex(P.L, save) return null } const p1Type = p1IsNum ? 'number' : 'word' const p2Type = p2IsNum ? 'number' : 'word' return mk(P, 'brace_expression', oStart, cEnd, [ mk(P, '{', oStart, oEnd, []), mk(P, p1Type, p1Start, p1End, []), mk(P, '..', dotStart, dotEnd, []), mk(P, p2Type, p2Start, p2End, []), mk(P, '}', cStart, cEnd, []), ])}
function tryParseBraceLikeCat(P: ParseState): TsNode[] | null { // {a,b,c} or {} → split into word fragments like tree-sitter does if (peek(P.L) !== '{') return null const oStart = P.L.b advance(P.L) const oEnd = P.L.b const inner: TsNode[] = [mk(P, 'word', oStart, oEnd, [])] while (P.L.i < P.L.len) { const bc = peek(P.L) // SECURITY: stop at command terminators so `{foo;rm x` splits correctly. if ( bc === '}' || bc === '\n' || bc === ';' || bc === '|' || bc === '&' || bc === ' ' || bc === '\t' || bc === '<' || bc === '>' || bc === '(' || bc === ')' ) { break } // `[` and `]` are single-char words: {o[k]} → { o [ k ] } if (bc === '[' || bc === ']') { const bStart = P.L.b advance(P.L) inner.push(mk(P, 'word', bStart, P.L.b, [])) continue } const midStart = P.L.b while (P.L.i < P.L.len) { const mc = peek(P.L) if ( mc === '}' || mc === '\n' || mc === ';' || mc === '|' || mc === '&' || mc === ' ' || mc === '\t' || mc === '<' || mc === '>' || mc === '(' || mc === ')' || mc === '[' || mc === ']' ) { break } advance(P.L) } const midEnd = P.L.b if (midEnd > midStart) { const midText = sliceBytes(P, midStart, midEnd) const midType = /^-?\d+$/.test(midText) ? 'number' : 'word' inner.push(mk(P, midType, midStart, midEnd, [])) } else { break } } if (peek(P.L) === '}') { const cStart = P.L.b advance(P.L) inner.push(mk(P, 'word', cStart, P.L.b, [])) } return inner}
function parseDoubleQuoted(P: ParseState): TsNode { const qStart = P.L.b advance(P.L) const qEnd = P.L.b const openQ = mk(P, '"', qStart, qEnd, []) const parts: TsNode[] = [openQ] let contentStart = P.L.b let contentStartI = P.L.i const flushContent = (): void => { if (P.L.b > contentStart) { // Tree-sitter's extras rule /\s/ has higher precedence than // string_content (prec -1), so whitespace-only segments are elided. // `" ${x} "` → (string (expansion)) not (string (string_content)(expansion)(string_content)). // Note: this intentionally diverges from preserving all content — cc // tests relying on whitespace-only string_content need updating // (CCReconcile). const txt = P.src.slice(contentStartI, P.L.i) if (!/^[ \t]+$/.test(txt)) { parts.push(mk(P, 'string_content', contentStart, P.L.b, [])) } } } while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '"') break if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '\n') { // Split string_content at newline flushContent() advance(P.L) contentStart = P.L.b contentStartI = P.L.i continue } if (c === '$') { const c1 = peek(P.L, 1) if ( c1 === '(' || c1 === '{' || isIdentStart(c1) || SPECIAL_VARS.has(c1) || isDigit(c1) ) { flushContent() const exp = parseDollarLike(P) if (exp) parts.push(exp) contentStart = P.L.b contentStartI = P.L.i continue } // Bare $ not at end-of-string: tree-sitter emits it as an anonymous // '$' token, which splits string_content. $ immediately before the // closing " is absorbed into the preceding string_content. if (c1 !== '"' && c1 !== '') { flushContent() const dS = P.L.b advance(P.L) parts.push(mk(P, '$', dS, P.L.b, [])) contentStart = P.L.b contentStartI = P.L.i continue } } if (c === '`') { flushContent() const bt = parseBacktick(P) if (bt) parts.push(bt) contentStart = P.L.b contentStartI = P.L.i continue } advance(P.L) } flushContent() let close: TsNode if (peek(P.L) === '"') { const cStart = P.L.b advance(P.L) close = mk(P, '"', cStart, P.L.b, []) } else { close = mk(P, '"', P.L.b, P.L.b, []) } parts.push(close) return mk(P, 'string', qStart, close.endIndex, parts)}
function parseDollarLike(P: ParseState): TsNode | null { const c1 = peek(P.L, 1) const dStart = P.L.b if (c1 === '(' && peek(P.L, 2) === '(') { // $(( arithmetic )) advance(P.L) advance(P.L) advance(P.L) const open = mk(P, '$((', dStart, P.L.b, []) const exprs = parseArithCommaList(P, '))', 'var') skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')' && peek(P.L, 1) === ')') { const cStart = P.L.b advance(P.L) advance(P.L) close = mk(P, '))', cStart, P.L.b, []) } else { close = mk(P, '))', P.L.b, P.L.b, []) } return mk(P, 'arithmetic_expansion', dStart, close.endIndex, [ open, ...exprs, close, ]) } if (c1 === '[') { // $[ arithmetic ] — legacy bash syntax, same as $((...)) advance(P.L) advance(P.L) const open = mk(P, '$[', dStart, P.L.b, []) const exprs = parseArithCommaList(P, ']', 'var') skipBlanks(P.L) let close: TsNode if (peek(P.L) === ']') { const cStart = P.L.b advance(P.L) close = mk(P, ']', cStart, P.L.b, []) } else { close = mk(P, ']', P.L.b, P.L.b, []) } return mk(P, 'arithmetic_expansion', dStart, close.endIndex, [ open, ...exprs, close, ]) } if (c1 === '(') { advance(P.L) advance(P.L) const open = mk(P, '$(', dStart, P.L.b, []) let body = parseStatements(P, ')') skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')') { const cStart = P.L.b advance(P.L) close = mk(P, ')', cStart, P.L.b, []) } else { close = mk(P, ')', P.L.b, P.L.b, []) } // $(< file) shorthand: unwrap redirected_statement → bare file_redirect // tree-sitter emits (command_substitution (file_redirect (word))) directly if ( body.length === 1 && body[0]!.type === 'redirected_statement' && body[0]!.children.length === 1 && body[0]!.children[0]!.type === 'file_redirect' ) { body = body[0]!.children } return mk(P, 'command_substitution', dStart, close.endIndex, [ open, ...body, close, ]) } if (c1 === '{') { advance(P.L) advance(P.L) const open = mk(P, '${', dStart, P.L.b, []) const inner = parseExpansionBody(P) let close: TsNode if (peek(P.L) === '}') { const cStart = P.L.b advance(P.L) close = mk(P, '}', cStart, P.L.b, []) } else { close = mk(P, '}', P.L.b, P.L.b, []) } return mk(P, 'expansion', dStart, close.endIndex, [open, ...inner, close]) } // Simple expansion $VAR or $? $$ $@ etc advance(P.L) const dEnd = P.L.b const dollar = mk(P, '$', dStart, dEnd, []) const nc = peek(P.L) // $_ is special_variable_name only when not followed by more ident chars if (nc === '_' && !isIdentChar(peek(P.L, 1))) { const vStart = P.L.b advance(P.L) const vn = mk(P, 'special_variable_name', vStart, P.L.b, []) return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]) } if (isIdentStart(nc)) { const vStart = P.L.b while (isIdentChar(peek(P.L))) advance(P.L) const vn = mk(P, 'variable_name', vStart, P.L.b, []) return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]) } if (isDigit(nc)) { const vStart = P.L.b advance(P.L) const vn = mk(P, 'variable_name', vStart, P.L.b, []) return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]) } if (SPECIAL_VARS.has(nc)) { const vStart = P.L.b advance(P.L) const vn = mk(P, 'special_variable_name', vStart, P.L.b, []) return mk(P, 'simple_expansion', dStart, P.L.b, [dollar, vn]) } // Bare $ — just a $ leaf (tree-sitter treats trailing $ as literal) return dollar}
function parseExpansionBody(P: ParseState): TsNode[] { const out: TsNode[] = [] skipBlanks(P.L) // Bizarre cases: ${#!} ${!#} ${!##} ${!# } ${!## } all emit empty (expansion) // — both # and ! become anonymous nodes when only combined with each other // and optional trailing space before }. Note ${!##/} does NOT match (has // content after), so it parses normally as (special_variable_name)(regex). { const c0 = peek(P.L) const c1 = peek(P.L, 1) if (c0 === '#' && c1 === '!' && peek(P.L, 2) === '}') { advance(P.L) advance(P.L) return out } if (c0 === '!' && c1 === '#') { // ${!#} ${!##} with optional trailing space then } let j = 2 if (peek(P.L, j) === '#') j++ if (peek(P.L, j) === ' ') j++ if (peek(P.L, j) === '}') { while (j-- > 0) advance(P.L) return out } } } // Optional # prefix for length if (peek(P.L) === '#') { const s = P.L.b advance(P.L) out.push(mk(P, '#', s, P.L.b, [])) } // Optional ! prefix for indirect expansion: ${!varname} ${!prefix*} ${!prefix@} // Only when followed by an identifier — ${!} alone is special var $! // Also = ~ prefixes (zsh-style ${=var} ${~var}) const pc = peek(P.L) if ( (pc === '!' || pc === '=' || pc === '~') && (isIdentStart(peek(P.L, 1)) || isDigit(peek(P.L, 1))) ) { const s = P.L.b advance(P.L) out.push(mk(P, pc, s, P.L.b, [])) } skipBlanks(P.L) // Variable name if (isIdentStart(peek(P.L))) { const s = P.L.b while (isIdentChar(peek(P.L))) advance(P.L) out.push(mk(P, 'variable_name', s, P.L.b, [])) } else if (isDigit(peek(P.L))) { const s = P.L.b while (isDigit(peek(P.L))) advance(P.L) out.push(mk(P, 'variable_name', s, P.L.b, [])) } else if (SPECIAL_VARS.has(peek(P.L))) { const s = P.L.b advance(P.L) out.push(mk(P, 'special_variable_name', s, P.L.b, [])) } // Optional subscript [idx] — parsed arithmetically if (peek(P.L) === '[') { const varNode = out[out.length - 1] const brOpen = P.L.b advance(P.L) const brOpenNode = mk(P, '[', brOpen, P.L.b, []) const idx = parseSubscriptIndexInline(P) skipBlanks(P.L) const brClose = P.L.b if (peek(P.L) === ']') advance(P.L) const brCloseNode = mk(P, ']', brClose, P.L.b, []) if (varNode) { const kids = idx ? [varNode, brOpenNode, idx, brCloseNode] : [varNode, brOpenNode, brCloseNode] out[out.length - 1] = mk(P, 'subscript', varNode.startIndex, P.L.b, kids) } } skipBlanks(P.L) // Trailing * or @ for indirect expansion (${!prefix*} ${!prefix@}) or // @operator for parameter transformation (${var@U} ${var@Q}) — anonymous const tc = peek(P.L) if ((tc === '*' || tc === '@') && peek(P.L, 1) === '}') { const s = P.L.b advance(P.L) out.push(mk(P, tc, s, P.L.b, [])) return out } if (tc === '@' && isIdentStart(peek(P.L, 1))) { // ${var@U} transformation — @ is anonymous, consume op char(s) const s = P.L.b advance(P.L) out.push(mk(P, '@', s, P.L.b, [])) while (isIdentChar(peek(P.L))) advance(P.L) return out } // Operator :- := :? :+ - = ? + # ## % %% / // ^ ^^ , ,, etc. const c = peek(P.L) // Bare `:` substring operator ${var:off:len} — offset and length parsed // arithmetically. Must come BEFORE the generic operator handling so `(` after // `:` goes to parenthesized_expression not the array path. `:-` `:=` `:?` // `:+` (no space) remain default-value operators; `: -1` (with space before // -1) is substring with negative offset. if (c === ':') { const c1 = peek(P.L, 1) // `:\n` or `:}` — empty substring expansion, emits nothing (variable_name only) if (c1 === '\n' || c1 === '}') { advance(P.L) while (peek(P.L) === '\n') advance(P.L) return out } if (c1 !== '-' && c1 !== '=' && c1 !== '?' && c1 !== '+') { advance(P.L) skipBlanks(P.L) // Offset — arithmetic. `-N` at top level is a single number node per // tree-sitter; inside parens it's unary_expression(number). const offC = peek(P.L) let off: TsNode | null if (offC === '-' && isDigit(peek(P.L, 1))) { const ns = P.L.b advance(P.L) while (isDigit(peek(P.L))) advance(P.L) off = mk(P, 'number', ns, P.L.b, []) } else { off = parseArithExpr(P, ':}', 'var') } if (off) out.push(off) skipBlanks(P.L) if (peek(P.L) === ':') { advance(P.L) skipBlanks(P.L) const lenC = peek(P.L) let len: TsNode | null if (lenC === '-' && isDigit(peek(P.L, 1))) { const ns = P.L.b advance(P.L) while (isDigit(peek(P.L))) advance(P.L) len = mk(P, 'number', ns, P.L.b, []) } else { len = parseArithExpr(P, '}', 'var') } if (len) out.push(len) } return out } } if ( c === ':' || c === '#' || c === '%' || c === '/' || c === '^' || c === ',' || c === '-' || c === '=' || c === '?' || c === '+' ) { const s = P.L.b const c1 = peek(P.L, 1) let op = c if (c === ':' && (c1 === '-' || c1 === '=' || c1 === '?' || c1 === '+')) { advance(P.L) advance(P.L) op = c + c1 } else if ( (c === '#' || c === '%' || c === '/' || c === '^' || c === ',') && c1 === c ) { // Doubled operators: ## %% // ^^ ,, advance(P.L) advance(P.L) op = c + c } else { advance(P.L) } out.push(mk(P, op, s, P.L.b, [])) // Rest is the default/replacement — parse as word or regex until } // Pattern-matching operators (# ## % %% / // ^ ^^ , ,,) emit regex; // value-substitution operators (:- := :? :+ - = ? + :) emit word. // `/` and `//` split at next `/` into (regex)+(word) for pat/repl. const isPattern = op === '#' || op === '##' || op === '%' || op === '%%' || op === '/' || op === '//' || op === '^' || op === '^^' || op === ',' || op === ',,' if (op === '/' || op === '//') { // Optional /# or /% anchor prefix — anonymous node const ac = peek(P.L) if (ac === '#' || ac === '%') { const aStart = P.L.b advance(P.L) out.push(mk(P, ac, aStart, P.L.b, [])) } // Pattern: per grammar _expansion_regex_replacement, pattern is // choice(regex, string, cmd_sub, seq(string, regex)). If it STARTS // with ", emit (string) and any trailing chars become (regex). // `${v//"${old}"/}` → (string(expansion)); `${v//"${c}"\//}` → // (string)(regex). if (peek(P.L) === '"') { out.push(parseDoubleQuoted(P)) const tail = parseExpansionRest(P, 'regex', true) if (tail) out.push(tail) } else { const regex = parseExpansionRest(P, 'regex', true) if (regex) out.push(regex) } if (peek(P.L) === '/') { const sepStart = P.L.b advance(P.L) out.push(mk(P, '/', sepStart, P.L.b, [])) // Replacement: per grammar, choice includes `seq(cmd_sub, word)` // which emits TWO siblings (not concatenation). Also `(` at start // of replacement is a regular word char, NOT array — unlike `:-` // default-value context. `${v/(/(Gentoo ${x}, }` replacement // `(Gentoo ${x}, ` is (concatenation (word)(expansion)(word)). const repl = parseExpansionRest(P, 'replword', false) if (repl) { // seq(cmd_sub, word) special case → siblings. Detected when // replacement is a concatenation of exactly 2 parts with first // being command_substitution. if ( repl.type === 'concatenation' && repl.children.length === 2 && repl.children[0]!.type === 'command_substitution' ) { out.push(repl.children[0]!) out.push(repl.children[1]!) } else { out.push(repl) } } } } else if (op === '#' || op === '##' || op === '%' || op === '%%') { // Pattern-removal: per grammar _expansion_regex, pattern is // repeat(choice(regex, string, raw_string, ')')). Each quote/string // is a SIBLING, not absorbed into one regex. `${f%'str'*}` → // (raw_string)(regex); `${f/'str'*}` (slash) stays single regex. for (const p of parseExpansionRegexSegmented(P)) out.push(p) } else { const rest = parseExpansionRest(P, isPattern ? 'regex' : 'word', false) if (rest) out.push(rest) } } return out}
function parseExpansionRest( P: ParseState, nodeType: string, stopAtSlash: boolean,): TsNode | null { // Don't skipBlanks — `${var:- }` space IS the word. Stop at } or newline // (`${var:\n}` emits no word). stopAtSlash=true stops at `/` for pat/repl // split in ${var/pat/repl}. nodeType 'replword' is word-mode for the // replacement in `/` `//` — same as 'word' but `(` is NOT array. const start = P.L.b // Value-substitution RHS starting with `(` parses as array: ${var:-(x)} → // (expansion (variable_name) (array (word))). Only for 'word' context (not // pattern-matching operators which emit regex, and not 'replword' where `(` // is a regular char per grammar `_expansion_regex_replacement`). if (nodeType === 'word' && peek(P.L) === '(') { advance(P.L) const open = mk(P, '(', start, P.L.b, []) const elems: TsNode[] = [open] while (P.L.i < P.L.len) { skipBlanks(P.L) const c = peek(P.L) if (c === ')' || c === '}' || c === '\n' || c === '') break const wStart = P.L.b while (P.L.i < P.L.len) { const wc = peek(P.L) if ( wc === ')' || wc === '}' || wc === ' ' || wc === '\t' || wc === '\n' || wc === '' ) { break } advance(P.L) } if (P.L.b > wStart) elems.push(mk(P, 'word', wStart, P.L.b, [])) else break } if (peek(P.L) === ')') { const cStart = P.L.b advance(P.L) elems.push(mk(P, ')', cStart, P.L.b, [])) } while (peek(P.L) === '\n') advance(P.L) return mk(P, 'array', start, P.L.b, elems) } // REGEX mode: flat single-span scan. Quotes are opaque (skipped past so // `/` inside them doesn't break stopAtSlash), but NOT emitted as separate // nodes — the entire range becomes one regex node. if (nodeType === 'regex') { let braceDepth = 0 while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\n') break if (braceDepth === 0) { if (c === '}') break if (stopAtSlash && c === '/') break } if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '"' || c === "'") { advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== c) { if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len) advance(P.L) advance(P.L) } if (peek(P.L) === c) advance(P.L) continue } // Skip past nested ${...} $(...) $[...] so their } / don't terminate us if (c === '$') { const c1 = peek(P.L, 1) if (c1 === '{') { let d = 0 advance(P.L) advance(P.L) d++ while (P.L.i < P.L.len && d > 0) { const nc = peek(P.L) if (nc === '{') d++ else if (nc === '}') d-- advance(P.L) } continue } if (c1 === '(') { let d = 0 advance(P.L) advance(P.L) d++ while (P.L.i < P.L.len && d > 0) { const nc = peek(P.L) if (nc === '(') d++ else if (nc === ')') d-- advance(P.L) } continue } } if (c === '{') braceDepth++ else if (c === '}' && braceDepth > 0) braceDepth-- advance(P.L) } const end = P.L.b while (peek(P.L) === '\n') advance(P.L) if (end === start) return null return mk(P, 'regex', start, end, []) } // WORD mode: segmenting parser — recognize nested ${...}, $(...), $'...', // "...", '...', $ident, <(...)/>(...); bare chars accumulate into word // segments. Multiple parts → wrapped in concatenation. const parts: TsNode[] = [] let segStart = P.L.b let braceDepth = 0 const flushSeg = (): void => { if (P.L.b > segStart) { parts.push(mk(P, 'word', segStart, P.L.b, [])) } } while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\n') break if (braceDepth === 0) { if (c === '}') break if (stopAtSlash && c === '/') break } if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } const c1 = peek(P.L, 1) if (c === '$') { if (c1 === '{' || c1 === '(' || c1 === '[') { flushSeg() const exp = parseDollarLike(P) if (exp) parts.push(exp) segStart = P.L.b continue } if (c1 === "'") { // $'...' ANSI-C string flushSeg() const aStart = P.L.b advance(P.L) advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== "'") { if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len) advance(P.L) advance(P.L) } if (peek(P.L) === "'") advance(P.L) parts.push(mk(P, 'ansi_c_string', aStart, P.L.b, [])) segStart = P.L.b continue } if (isIdentStart(c1) || isDigit(c1) || SPECIAL_VARS.has(c1)) { flushSeg() const exp = parseDollarLike(P) if (exp) parts.push(exp) segStart = P.L.b continue } } if (c === '"') { flushSeg() parts.push(parseDoubleQuoted(P)) segStart = P.L.b continue } if (c === "'") { flushSeg() const rStart = P.L.b advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== "'") advance(P.L) if (peek(P.L) === "'") advance(P.L) parts.push(mk(P, 'raw_string', rStart, P.L.b, [])) segStart = P.L.b continue } if ((c === '<' || c === '>') && c1 === '(') { flushSeg() const ps = parseProcessSub(P) if (ps) parts.push(ps) segStart = P.L.b continue } if (c === '`') { flushSeg() const bt = parseBacktick(P) if (bt) parts.push(bt) segStart = P.L.b continue } // Brace tracking so nested {a,b} brace-expansion chars don't prematurely // terminate (rare, but the `?` in `${cond}? (` should be treated as word). if (c === '{') braceDepth++ else if (c === '}' && braceDepth > 0) braceDepth-- advance(P.L) } flushSeg() // Consume trailing newlines before } so caller sees } while (peek(P.L) === '\n') advance(P.L) // Tree-sitter skips leading whitespace (extras) in expansion RHS when // there's content after: `${2+ ${2}}` → just (expansion). But `${v:- }` // (space-only RHS) keeps the space as (word). So drop leading whitespace- // only word segment if it's NOT the only part. if ( parts.length > 1 && parts[0]!.type === 'word' && /^[ \t]+$/.test(parts[0]!.text) ) { parts.shift() } if (parts.length === 0) return null if (parts.length === 1) return parts[0]! // Multiple parts: wrap in concatenation (word mode keeps concat wrapping; // regex mode also concats per tree-sitter for mixed quote+glob patterns). const last = parts[parts.length - 1]! return mk(P, 'concatenation', parts[0]!.startIndex, last.endIndex, parts)}
// Pattern for # ## % %% operators — per grammar _expansion_regex:// repeat(choice(regex, string, raw_string, ')', /\s+/→regex)). Each quote// becomes a SIBLING node, not absorbed. `${f%'str'*}` → (raw_string)(regex).function parseExpansionRegexSegmented(P: ParseState): TsNode[] { const out: TsNode[] = [] let segStart = P.L.b const flushRegex = (): void => { if (P.L.b > segStart) out.push(mk(P, 'regex', segStart, P.L.b, [])) } while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '}' || c === '\n') break if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '"') { flushRegex() out.push(parseDoubleQuoted(P)) segStart = P.L.b continue } if (c === "'") { flushRegex() const rStart = P.L.b advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== "'") advance(P.L) if (peek(P.L) === "'") advance(P.L) out.push(mk(P, 'raw_string', rStart, P.L.b, [])) segStart = P.L.b continue } // Nested ${...} $(...) — opaque scan so their } doesn't terminate us if (c === '$') { const c1 = peek(P.L, 1) if (c1 === '{') { let d = 1 advance(P.L) advance(P.L) while (P.L.i < P.L.len && d > 0) { const nc = peek(P.L) if (nc === '{') d++ else if (nc === '}') d-- advance(P.L) } continue } if (c1 === '(') { let d = 1 advance(P.L) advance(P.L) while (P.L.i < P.L.len && d > 0) { const nc = peek(P.L) if (nc === '(') d++ else if (nc === ')') d-- advance(P.L) } continue } } advance(P.L) } flushRegex() while (peek(P.L) === '\n') advance(P.L) return out}
function parseBacktick(P: ParseState): TsNode | null { const start = P.L.b advance(P.L) const open = mk(P, '`', start, P.L.b, []) P.inBacktick++ // Parse statements inline — stop at closing backtick const body: TsNode[] = [] while (true) { skipBlanks(P.L) if (peek(P.L) === '`' || peek(P.L) === '') break const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'EOF' || t.type === 'BACKTICK') { restoreLex(P.L, save) break } if (t.type === 'NEWLINE') continue restoreLex(P.L, save) const stmt = parseAndOr(P) if (!stmt) break body.push(stmt) skipBlanks(P.L) if (peek(P.L) === '`') break const save2 = saveLex(P.L) const sep = nextToken(P.L, 'cmd') if (sep.type === 'OP' && (sep.value === ';' || sep.value === '&')) { body.push(leaf(P, sep.value, sep)) } else if (sep.type !== 'NEWLINE') { restoreLex(P.L, save2) } } P.inBacktick-- let close: TsNode if (peek(P.L) === '`') { const cStart = P.L.b advance(P.L) close = mk(P, '`', cStart, P.L.b, []) } else { close = mk(P, '`', P.L.b, P.L.b, []) } // Empty backticks (whitespace/newline only) are elided entirely by // tree-sitter — used as a line-continuation hack: "foo"`<newline>`"bar" // → (concatenation (string) (string)) with no command_substitution. if (body.length === 0) return null return mk(P, 'command_substitution', start, close.endIndex, [ open, ...body, close, ])}
function parseIf(P: ParseState, ifTok: Token): TsNode { const ifKw = leaf(P, 'if', ifTok) const kids: TsNode[] = [ifKw] const cond = parseStatements(P, null) kids.push(...cond) consumeKeyword(P, 'then', kids) const body = parseStatements(P, null) kids.push(...body) while (true) { const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'WORD' && t.value === 'elif') { const eKw = leaf(P, 'elif', t) const eCond = parseStatements(P, null) const eKids: TsNode[] = [eKw, ...eCond] consumeKeyword(P, 'then', eKids) const eBody = parseStatements(P, null) eKids.push(...eBody) const last = eKids[eKids.length - 1]! kids.push(mk(P, 'elif_clause', eKw.startIndex, last.endIndex, eKids)) } else if (t.type === 'WORD' && t.value === 'else') { const elKw = leaf(P, 'else', t) const elBody = parseStatements(P, null) const last = elBody.length > 0 ? elBody[elBody.length - 1]! : elKw kids.push( mk(P, 'else_clause', elKw.startIndex, last.endIndex, [elKw, ...elBody]), ) } else { restoreLex(P.L, save) break } } consumeKeyword(P, 'fi', kids) const last = kids[kids.length - 1]! return mk(P, 'if_statement', ifKw.startIndex, last.endIndex, kids)}
function parseWhile(P: ParseState, kwTok: Token): TsNode { const kw = leaf(P, kwTok.value, kwTok) const kids: TsNode[] = [kw] const cond = parseStatements(P, null) kids.push(...cond) const dg = parseDoGroup(P) if (dg) kids.push(dg) const last = kids[kids.length - 1]! return mk(P, 'while_statement', kw.startIndex, last.endIndex, kids)}
function parseFor(P: ParseState, forTok: Token): TsNode { const forKw = leaf(P, forTok.value, forTok) skipBlanks(P.L) // C-style for (( ; ; )) — only for `for`, not `select` if (forTok.value === 'for' && peek(P.L) === '(' && peek(P.L, 1) === '(') { const oStart = P.L.b advance(P.L) advance(P.L) const open = mk(P, '((', oStart, P.L.b, []) const kids: TsNode[] = [forKw, open] // init; cond; update — all three use 'assign' mode so `c = expr` emits // variable_assignment, while bare idents (c in `c<=5`) → word. Each // clause may be a comma-separated list. for (let k = 0; k < 3; k++) { skipBlanks(P.L) const es = parseArithCommaList(P, k < 2 ? ';' : '))', 'assign') kids.push(...es) if (k < 2) { if (peek(P.L) === ';') { const s = P.L.b advance(P.L) kids.push(mk(P, ';', s, P.L.b, [])) } } } skipBlanks(P.L) if (peek(P.L) === ')' && peek(P.L, 1) === ')') { const cStart = P.L.b advance(P.L) advance(P.L) kids.push(mk(P, '))', cStart, P.L.b, [])) } // Optional ; or newline const save = saveLex(P.L) const sep = nextToken(P.L, 'cmd') if (sep.type === 'OP' && sep.value === ';') { kids.push(leaf(P, ';', sep)) } else if (sep.type !== 'NEWLINE') { restoreLex(P.L, save) } const dg = parseDoGroup(P) if (dg) { kids.push(dg) } else { // C-style for can also use `{ ... }` body instead of `do ... done` skipNewlines(P) skipBlanks(P.L) if (peek(P.L) === '{') { const bOpen = P.L.b advance(P.L) const brace = mk(P, '{', bOpen, P.L.b, []) const body = parseStatements(P, '}') let bClose: TsNode if (peek(P.L) === '}') { const cs = P.L.b advance(P.L) bClose = mk(P, '}', cs, P.L.b, []) } else { bClose = mk(P, '}', P.L.b, P.L.b, []) } kids.push( mk(P, 'compound_statement', brace.startIndex, bClose.endIndex, [ brace, ...body, bClose, ]), ) } } const last = kids[kids.length - 1]! return mk(P, 'c_style_for_statement', forKw.startIndex, last.endIndex, kids) } // Regular for VAR in words; do ... done const kids: TsNode[] = [forKw] const varTok = nextToken(P.L, 'arg') kids.push(mk(P, 'variable_name', varTok.start, varTok.end, [])) skipBlanks(P.L) const save = saveLex(P.L) const inTok = nextToken(P.L, 'arg') if (inTok.type === 'WORD' && inTok.value === 'in') { kids.push(leaf(P, 'in', inTok)) while (true) { skipBlanks(P.L) const c = peek(P.L) if (c === ';' || c === '\n' || c === '') break const w = parseWord(P, 'arg') if (!w) break kids.push(w) } } else { restoreLex(P.L, save) } // Separator const save2 = saveLex(P.L) const sep = nextToken(P.L, 'cmd') if (sep.type === 'OP' && sep.value === ';') { kids.push(leaf(P, ';', sep)) } else if (sep.type !== 'NEWLINE') { restoreLex(P.L, save2) } const dg = parseDoGroup(P) if (dg) kids.push(dg) const last = kids[kids.length - 1]! return mk(P, 'for_statement', forKw.startIndex, last.endIndex, kids)}
function parseDoGroup(P: ParseState): TsNode | null { skipNewlines(P) const save = saveLex(P.L) const doTok = nextToken(P.L, 'cmd') if (doTok.type !== 'WORD' || doTok.value !== 'do') { restoreLex(P.L, save) return null } const doKw = leaf(P, 'do', doTok) const body = parseStatements(P, null) const kids: TsNode[] = [doKw, ...body] consumeKeyword(P, 'done', kids) const last = kids[kids.length - 1]! return mk(P, 'do_group', doKw.startIndex, last.endIndex, kids)}
function parseCase(P: ParseState, caseTok: Token): TsNode { const caseKw = leaf(P, 'case', caseTok) const kids: TsNode[] = [caseKw] skipBlanks(P.L) const word = parseWord(P, 'arg') if (word) kids.push(word) skipBlanks(P.L) consumeKeyword(P, 'in', kids) skipNewlines(P) while (true) { skipBlanks(P.L) skipNewlines(P) const save = saveLex(P.L) const t = nextToken(P.L, 'arg') if (t.type === 'WORD' && t.value === 'esac') { kids.push(leaf(P, 'esac', t)) break } if (t.type === 'EOF') break restoreLex(P.L, save) const item = parseCaseItem(P) if (!item) break kids.push(item) } const last = kids[kids.length - 1]! return mk(P, 'case_statement', caseKw.startIndex, last.endIndex, kids)}
function parseCaseItem(P: ParseState): TsNode | null { skipBlanks(P.L) const start = P.L.b const kids: TsNode[] = [] // Optional leading '(' before pattern — bash allows (pattern) syntax if (peek(P.L) === '(') { const s = P.L.b advance(P.L) kids.push(mk(P, '(', s, P.L.b, [])) } // Pattern(s) let isFirstAlt = true while (true) { skipBlanks(P.L) const c = peek(P.L) if (c === ')' || c === '') break const pats = parseCasePattern(P) if (pats.length === 0) break // tree-sitter quirk: first alternative with quotes is inlined as flat // siblings; subsequent alternatives are wrapped in (concatenation) with // `word` instead of `extglob_pattern` for bare segments. if (!isFirstAlt && pats.length > 1) { const rewritten = pats.map(p => p.type === 'extglob_pattern' ? mk(P, 'word', p.startIndex, p.endIndex, []) : p, ) const first = rewritten[0]! const last = rewritten[rewritten.length - 1]! kids.push( mk(P, 'concatenation', first.startIndex, last.endIndex, rewritten), ) } else { kids.push(...pats) } isFirstAlt = false skipBlanks(P.L) // \<newline> line continuation between alternatives if (peek(P.L) === '\\' && peek(P.L, 1) === '\n') { advance(P.L) advance(P.L) skipBlanks(P.L) } if (peek(P.L) === '|') { const s = P.L.b advance(P.L) kids.push(mk(P, '|', s, P.L.b, [])) // \<newline> after | is also a line continuation if (peek(P.L) === '\\' && peek(P.L, 1) === '\n') { advance(P.L) advance(P.L) } } else { break } } if (peek(P.L) === ')') { const s = P.L.b advance(P.L) kids.push(mk(P, ')', s, P.L.b, [])) } const body = parseStatements(P, null) kids.push(...body) const save = saveLex(P.L) const term = nextToken(P.L, 'cmd') if ( term.type === 'OP' && (term.value === ';;' || term.value === ';&' || term.value === ';;&') ) { kids.push(leaf(P, term.value, term)) } else { restoreLex(P.L, save) } if (kids.length === 0) return null // tree-sitter quirk: case_item with EMPTY body and a single pattern matching // extglob-operator-char-prefix (no actual glob metachars) downgrades to word. // `-o) owner=$2 ;;` (has body) → extglob_pattern; `-g) ;;` (empty) → word. if (body.length === 0) { for (let i = 0; i < kids.length; i++) { const k = kids[i]! if (k.type !== 'extglob_pattern') continue const text = sliceBytes(P, k.startIndex, k.endIndex) if (/^[-+?*@!][a-zA-Z]/.test(text) && !/[*?(]/.test(text)) { kids[i] = mk(P, 'word', k.startIndex, k.endIndex, []) } } } const last = kids[kids.length - 1]! return mk(P, 'case_item', start, last.endIndex, kids)}
function parseCasePattern(P: ParseState): TsNode[] { skipBlanks(P.L) const save = saveLex(P.L) const start = P.L.b const startI = P.L.i let parenDepth = 0 let hasDollar = false let hasBracketOutsideParen = false let hasQuote = false while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\\' && P.L.i + 1 < P.L.len) { // Escaped char — consume both (handles `bar\ baz` as single pattern) // \<newline> is a line continuation; eat it but stay in pattern. advance(P.L) advance(P.L) continue } if (c === '"' || c === "'") { hasQuote = true // Skip past the quoted segment so its content (spaces, |, etc.) doesn't // break the peek-ahead scan. advance(P.L) while (P.L.i < P.L.len && peek(P.L) !== c) { if (peek(P.L) === '\\' && P.L.i + 1 < P.L.len) advance(P.L) advance(P.L) } if (peek(P.L) === c) advance(P.L) continue } // Paren counting: any ( inside pattern opens a scope; don't break at ) or | // until balanced. Handles extglob *(a|b) and nested shapes *([0-9])([0-9]). if (c === '(') { parenDepth++ advance(P.L) continue } if (parenDepth > 0) { if (c === ')') { parenDepth-- advance(P.L) continue } if (c === '\n') break advance(P.L) continue } if (c === ')' || c === '|' || c === ' ' || c === '\t' || c === '\n') break if (c === '$') hasDollar = true if (c === '[') hasBracketOutsideParen = true advance(P.L) } if (P.L.b === start) return [] const text = P.src.slice(startI, P.L.i) const hasExtglobParen = /[*?+@!]\(/.test(text) // Quoted segments in pattern: tree-sitter splits at quote boundaries into // multiple sibling nodes. `*"foo"*` → (extglob_pattern)(string)(extglob_pattern). // Re-scan with a segmenting pass. if (hasQuote && !hasExtglobParen) { restoreLex(P.L, save) return parseCasePatternSegmented(P) } // tree-sitter splits patterns with [ or $ into concatenation via word parsing // UNLESS pattern has extglob parens (those override and emit extglob_pattern). // `*.[1357]` → concat(word word number word); `${PN}.pot` → concat(expansion word); // but `*([0-9])` → extglob_pattern (has extglob paren). if (!hasExtglobParen && (hasDollar || hasBracketOutsideParen)) { restoreLex(P.L, save) const w = parseWord(P, 'arg') return w ? [w] : [] } // Patterns starting with extglob operator chars (+ - ? * @ !) followed by // identifier chars are extglob_pattern per tree-sitter, even without parens // or glob metachars. `-o)` → extglob_pattern; plain `foo)` → word. const type = hasExtglobParen || /[*?]/.test(text) || /^[-+?*@!][a-zA-Z]/.test(text) ? 'extglob_pattern' : 'word' return [mk(P, type, start, P.L.b, [])]}
// Segmented scan for case patterns containing quotes: `*"foo"*` →// [extglob_pattern, string, extglob_pattern]. Bare segments → extglob_pattern// if they have */?, else word. Stops at ) | space tab newline outside quotes.function parseCasePatternSegmented(P: ParseState): TsNode[] { const parts: TsNode[] = [] let segStart = P.L.b let segStartI = P.L.i const flushSeg = (): void => { if (P.L.i > segStartI) { const t = P.src.slice(segStartI, P.L.i) const type = /[*?]/.test(t) ? 'extglob_pattern' : 'word' parts.push(mk(P, type, segStart, P.L.b, [])) } } while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '"') { flushSeg() parts.push(parseDoubleQuoted(P)) segStart = P.L.b segStartI = P.L.i continue } if (c === "'") { flushSeg() const tok = nextToken(P.L, 'arg') parts.push(leaf(P, 'raw_string', tok)) segStart = P.L.b segStartI = P.L.i continue } if (c === ')' || c === '|' || c === ' ' || c === '\t' || c === '\n') break advance(P.L) } flushSeg() return parts}
function parseFunction(P: ParseState, fnTok: Token): TsNode { const fnKw = leaf(P, 'function', fnTok) skipBlanks(P.L) const nameTok = nextToken(P.L, 'arg') const name = mk(P, 'word', nameTok.start, nameTok.end, []) const kids: TsNode[] = [fnKw, name] skipBlanks(P.L) if (peek(P.L) === '(' && peek(P.L, 1) === ')') { const o = nextToken(P.L, 'cmd') const c = nextToken(P.L, 'cmd') kids.push(leaf(P, '(', o)) kids.push(leaf(P, ')', c)) } skipBlanks(P.L) skipNewlines(P) const body = parseCommand(P) if (body) { // Hoist redirects from redirected_statement(compound_statement, ...) to // function_definition level per tree-sitter grammar if ( body.type === 'redirected_statement' && body.children.length >= 2 && body.children[0]!.type === 'compound_statement' ) { kids.push(...body.children) } else { kids.push(body) } } const last = kids[kids.length - 1]! return mk(P, 'function_definition', fnKw.startIndex, last.endIndex, kids)}
function parseDeclaration(P: ParseState, kwTok: Token): TsNode { const kw = leaf(P, kwTok.value, kwTok) const kids: TsNode[] = [kw] while (true) { skipBlanks(P.L) const c = peek(P.L) if ( c === '' || c === '\n' || c === ';' || c === '&' || c === '|' || c === ')' || c === '<' || c === '>' ) { break } const a = tryParseAssignment(P) if (a) { kids.push(a) continue } // Quoted string or concatenation: `export "FOO=bar"`, `export 'X'` if (c === '"' || c === "'" || c === '$') { const w = parseWord(P, 'arg') if (w) { kids.push(w) continue } break } // Flag like -a or bare variable name const save = saveLex(P.L) const tok = nextToken(P.L, 'arg') if (tok.type === 'WORD' || tok.type === 'NUMBER') { if (tok.value.startsWith('-')) { kids.push(leaf(P, 'word', tok)) } else if (isIdentStart(tok.value[0] ?? '')) { kids.push(mk(P, 'variable_name', tok.start, tok.end, [])) } else { kids.push(leaf(P, 'word', tok)) } } else { restoreLex(P.L, save) break } } const last = kids[kids.length - 1]! return mk(P, 'declaration_command', kw.startIndex, last.endIndex, kids)}
function parseUnset(P: ParseState, kwTok: Token): TsNode { const kw = leaf(P, 'unset', kwTok) const kids: TsNode[] = [kw] while (true) { skipBlanks(P.L) const c = peek(P.L) if ( c === '' || c === '\n' || c === ';' || c === '&' || c === '|' || c === ')' || c === '<' || c === '>' ) { break } // SECURITY: use parseWord (not raw nextToken) so quoted strings like // `unset 'a[$(id)]'` emit a raw_string child that ast.ts can reject. // Previously `break` silently dropped non-WORD args — hiding the // arithmetic-subscript code-exec vector from the security walker. const arg = parseWord(P, 'arg') if (!arg) break if (arg.type === 'word') { if (arg.text.startsWith('-')) { kids.push(arg) } else { kids.push(mk(P, 'variable_name', arg.startIndex, arg.endIndex, [])) } } else { kids.push(arg) } } const last = kids[kids.length - 1]! return mk(P, 'unset_command', kw.startIndex, last.endIndex, kids)}
function consumeKeyword(P: ParseState, name: string, kids: TsNode[]): void { skipNewlines(P) const save = saveLex(P.L) const t = nextToken(P.L, 'cmd') if (t.type === 'WORD' && t.value === name) { kids.push(leaf(P, name, t)) } else { restoreLex(P.L, save) }}
// ───────────────────── Test & Arithmetic Expressions ─────────────────────
function parseTestExpr(P: ParseState, closer: string): TsNode | null { return parseTestOr(P, closer)}
function parseTestOr(P: ParseState, closer: string): TsNode | null { let left = parseTestAnd(P, closer) if (!left) return null while (true) { skipBlanks(P.L) const save = saveLex(P.L) if (peek(P.L) === '|' && peek(P.L, 1) === '|') { const s = P.L.b advance(P.L) advance(P.L) const op = mk(P, '||', s, P.L.b, []) const right = parseTestAnd(P, closer) if (!right) { restoreLex(P.L, save) break } left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [ left, op, right, ]) } else { break } } return left}
function parseTestAnd(P: ParseState, closer: string): TsNode | null { let left = parseTestUnary(P, closer) if (!left) return null while (true) { skipBlanks(P.L) if (peek(P.L) === '&' && peek(P.L, 1) === '&') { const s = P.L.b advance(P.L) advance(P.L) const op = mk(P, '&&', s, P.L.b, []) const right = parseTestUnary(P, closer) if (!right) break left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [ left, op, right, ]) } else { break } } return left}
function parseTestUnary(P: ParseState, closer: string): TsNode | null { skipBlanks(P.L) const c = peek(P.L) if (c === '(') { const s = P.L.b advance(P.L) const open = mk(P, '(', s, P.L.b, []) const inner = parseTestOr(P, closer) skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')') { const cs = P.L.b advance(P.L) close = mk(P, ')', cs, P.L.b, []) } else { close = mk(P, ')', P.L.b, P.L.b, []) } const kids = inner ? [open, inner, close] : [open, close] return mk( P, 'parenthesized_expression', open.startIndex, close.endIndex, kids, ) } return parseTestBinary(P, closer)}
/** * Parse `!`-negated or test-operator (`-f`) or parenthesized primary — but NOT * a binary comparison. Used as LHS of binary_expression so `! x =~ y` binds * `!` to `x` only, not the whole `x =~ y`. */function parseTestNegatablePrimary( P: ParseState, closer: string,): TsNode | null { skipBlanks(P.L) const c = peek(P.L) if (c === '!') { const s = P.L.b advance(P.L) const bang = mk(P, '!', s, P.L.b, []) const inner = parseTestNegatablePrimary(P, closer) if (!inner) return bang return mk(P, 'unary_expression', bang.startIndex, inner.endIndex, [ bang, inner, ]) } if (c === '-' && isIdentStart(peek(P.L, 1))) { const s = P.L.b advance(P.L) while (isIdentChar(peek(P.L))) advance(P.L) const op = mk(P, 'test_operator', s, P.L.b, []) skipBlanks(P.L) const arg = parseTestPrimary(P, closer) if (!arg) return op return mk(P, 'unary_expression', op.startIndex, arg.endIndex, [op, arg]) } return parseTestPrimary(P, closer)}
function parseTestBinary(P: ParseState, closer: string): TsNode | null { skipBlanks(P.L) // `!` in test context binds tighter than =~/==. // `[[ ! "x" =~ y ]]` → (binary_expression (unary_expression (string)) (regex)) // `[[ ! -f x ]]` → (unary_expression ! (unary_expression (test_operator) (word))) const left = parseTestNegatablePrimary(P, closer) if (!left) return null skipBlanks(P.L) // Binary comparison: == != =~ -eq -lt etc. const c = peek(P.L) const c1 = peek(P.L, 1) let op: TsNode | null = null const os = P.L.b if (c === '=' && c1 === '=') { advance(P.L) advance(P.L) op = mk(P, '==', os, P.L.b, []) } else if (c === '!' && c1 === '=') { advance(P.L) advance(P.L) op = mk(P, '!=', os, P.L.b, []) } else if (c === '=' && c1 === '~') { advance(P.L) advance(P.L) op = mk(P, '=~', os, P.L.b, []) } else if (c === '=' && c1 !== '=') { advance(P.L) op = mk(P, '=', os, P.L.b, []) } else if (c === '<' && c1 !== '<') { advance(P.L) op = mk(P, '<', os, P.L.b, []) } else if (c === '>' && c1 !== '>') { advance(P.L) op = mk(P, '>', os, P.L.b, []) } else if (c === '-' && isIdentStart(c1)) { advance(P.L) while (isIdentChar(peek(P.L))) advance(P.L) op = mk(P, 'test_operator', os, P.L.b, []) } if (!op) return left skipBlanks(P.L) // In [[ ]], RHS of ==/!=/=/=~ gets special pattern parsing: paren counting // so @(a|b|c) doesn't break on |, and segments become extglob_pattern/regex. if (closer === ']]') { const opText = op.type if (opText === '=~') { skipBlanks(P.L) // If the ENTIRE RHS is a quoted string, emit string/raw_string not // regex: `[[ "$x" =~ "$y" ]]` → (binary_expression (string) (string)). // If there's content after the quote (`' boop '(.*)$`), the whole RHS // stays a single (regex). Peek past the quote to check. const rc = peek(P.L) let rhs: TsNode | null = null if (rc === '"' || rc === "'") { const save = saveLex(P.L) const quoted = rc === '"' ? parseDoubleQuoted(P) : leaf(P, 'raw_string', nextToken(P.L, 'arg')) // Check if RHS ends here: only whitespace then ]] or &&/|| or newline let j = P.L.i while (j < P.L.len && (P.src[j] === ' ' || P.src[j] === '\t')) j++ const nc = P.src[j] ?? '' const nc1 = P.src[j + 1] ?? '' if ( (nc === ']' && nc1 === ']') || (nc === '&' && nc1 === '&') || (nc === '|' && nc1 === '|') || nc === '\n' || nc === '' ) { rhs = quoted } else { restoreLex(P.L, save) } } if (!rhs) rhs = parseTestRegexRhs(P) if (!rhs) return left return mk(P, 'binary_expression', left.startIndex, rhs.endIndex, [ left, op, rhs, ]) } // Single `=` emits (regex) per tree-sitter; `==` and `!=` emit extglob_pattern if (opText === '=') { const rhs = parseTestRegexRhs(P) if (!rhs) return left return mk(P, 'binary_expression', left.startIndex, rhs.endIndex, [ left, op, rhs, ]) } if (opText === '==' || opText === '!=') { const parts = parseTestExtglobRhs(P) if (parts.length === 0) return left const last = parts[parts.length - 1]! return mk(P, 'binary_expression', left.startIndex, last.endIndex, [ left, op, ...parts, ]) } } const right = parseTestPrimary(P, closer) if (!right) return left return mk(P, 'binary_expression', left.startIndex, right.endIndex, [ left, op, right, ])}
// RHS of =~ in [[ ]] — scan as single (regex) node with paren/bracket counting// so | ( ) inside the regex don't break parsing. Stop at ]] or ws+&&/||.function parseTestRegexRhs(P: ParseState): TsNode | null { skipBlanks(P.L) const start = P.L.b let parenDepth = 0 let bracketDepth = 0 while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '\n') break if (parenDepth === 0 && bracketDepth === 0) { if (c === ']' && peek(P.L, 1) === ']') break if (c === ' ' || c === '\t') { // Peek past blanks for ]] or &&/|| let j = P.L.i while (j < P.L.len && (P.L.src[j] === ' ' || P.L.src[j] === '\t')) j++ const nc = P.L.src[j] ?? '' const nc1 = P.L.src[j + 1] ?? '' if ( (nc === ']' && nc1 === ']') || (nc === '&' && nc1 === '&') || (nc === '|' && nc1 === '|') ) { break } advance(P.L) continue } } if (c === '(') parenDepth++ else if (c === ')' && parenDepth > 0) parenDepth-- else if (c === '[') bracketDepth++ else if (c === ']' && bracketDepth > 0) bracketDepth-- advance(P.L) } if (P.L.b === start) return null return mk(P, 'regex', start, P.L.b, [])}
// RHS of ==/!=/= in [[ ]] — returns array of parts. Bare text → extglob_pattern// (with paren counting for @(a|b)); $(...)/${}/quoted → proper node types.// Multiple parts become flat children of binary_expression per tree-sitter.function parseTestExtglobRhs(P: ParseState): TsNode[] { skipBlanks(P.L) const parts: TsNode[] = [] let segStart = P.L.b let segStartI = P.L.i let parenDepth = 0 const flushSeg = () => { if (P.L.i > segStartI) { const text = P.src.slice(segStartI, P.L.i) // Pure number stays number; everything else is extglob_pattern const type = /^\d+$/.test(text) ? 'number' : 'extglob_pattern' parts.push(mk(P, type, segStart, P.L.b, [])) } } while (P.L.i < P.L.len) { const c = peek(P.L) if (c === '\\' && P.L.i + 1 < P.L.len) { advance(P.L) advance(P.L) continue } if (c === '\n') break if (parenDepth === 0) { if (c === ']' && peek(P.L, 1) === ']') break if (c === ' ' || c === '\t') { let j = P.L.i while (j < P.L.len && (P.L.src[j] === ' ' || P.L.src[j] === '\t')) j++ const nc = P.L.src[j] ?? '' const nc1 = P.L.src[j + 1] ?? '' if ( (nc === ']' && nc1 === ']') || (nc === '&' && nc1 === '&') || (nc === '|' && nc1 === '|') ) { break } advance(P.L) continue } } // $ " ' must be parsed even inside @( ) extglob parens — parseDollarLike // consumes matching ) so parenDepth stays consistent. if (c === '$') { const c1 = peek(P.L, 1) if ( c1 === '(' || c1 === '{' || isIdentStart(c1) || SPECIAL_VARS.has(c1) ) { flushSeg() const exp = parseDollarLike(P) if (exp) parts.push(exp) segStart = P.L.b segStartI = P.L.i continue } } if (c === '"') { flushSeg() parts.push(parseDoubleQuoted(P)) segStart = P.L.b segStartI = P.L.i continue } if (c === "'") { flushSeg() const tok = nextToken(P.L, 'arg') parts.push(leaf(P, 'raw_string', tok)) segStart = P.L.b segStartI = P.L.i continue } if (c === '(') parenDepth++ else if (c === ')' && parenDepth > 0) parenDepth-- advance(P.L) } flushSeg() return parts}
function parseTestPrimary(P: ParseState, closer: string): TsNode | null { skipBlanks(P.L) // Stop at closer if (closer === ']' && peek(P.L) === ']') return null if (closer === ']]' && peek(P.L) === ']' && peek(P.L, 1) === ']') return null return parseWord(P, 'arg')}
/** * Arithmetic context modes: * - 'var': bare identifiers → variable_name (default, used in $((..)), ((..))) * - 'word': bare identifiers → word (c-style for head condition/update clauses) * - 'assign': identifiers with = → variable_assignment (c-style for init clause) */type ArithMode = 'var' | 'word' | 'assign'
/** Operator precedence table (higher = tighter binding). */const ARITH_PREC: Record<string, number> = { '=': 2, '+=': 2, '-=': 2, '*=': 2, '/=': 2, '%=': 2, '<<=': 2, '>>=': 2, '&=': 2, '^=': 2, '|=': 2, '||': 4, '&&': 5, '|': 6, '^': 7, '&': 8, '==': 9, '!=': 9, '<': 10, '>': 10, '<=': 10, '>=': 10, '<<': 11, '>>': 11, '+': 12, '-': 12, '*': 13, '/': 13, '%': 13, '**': 14,}
/** Right-associative operators (assignment and exponent). */const ARITH_RIGHT_ASSOC = new Set([ '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '&=', '^=', '|=', '**',])
function parseArithExpr( P: ParseState, stop: string, mode: ArithMode = 'var',): TsNode | null { return parseArithTernary(P, stop, mode)}
/** Top-level: comma-separated list. arithmetic_expansion emits multiple children. */function parseArithCommaList( P: ParseState, stop: string, mode: ArithMode = 'var',): TsNode[] { const out: TsNode[] = [] while (true) { const e = parseArithTernary(P, stop, mode) if (e) out.push(e) skipBlanks(P.L) if (peek(P.L) === ',' && !isArithStop(P, stop)) { advance(P.L) continue } break } return out}
function parseArithTernary( P: ParseState, stop: string, mode: ArithMode,): TsNode | null { const cond = parseArithBinary(P, stop, 0, mode) if (!cond) return null skipBlanks(P.L) if (peek(P.L) === '?') { const qs = P.L.b advance(P.L) const q = mk(P, '?', qs, P.L.b, []) const t = parseArithBinary(P, ':', 0, mode) skipBlanks(P.L) let colon: TsNode if (peek(P.L) === ':') { const cs = P.L.b advance(P.L) colon = mk(P, ':', cs, P.L.b, []) } else { colon = mk(P, ':', P.L.b, P.L.b, []) } const f = parseArithTernary(P, stop, mode) const last = f ?? colon const kids: TsNode[] = [cond, q] if (t) kids.push(t) kids.push(colon) if (f) kids.push(f) return mk(P, 'ternary_expression', cond.startIndex, last.endIndex, kids) } return cond}
/** Scan next arithmetic binary operator; returns [text, length] or null. */function scanArithOp(P: ParseState): [string, number] | null { const c = peek(P.L) const c1 = peek(P.L, 1) const c2 = peek(P.L, 2) // 3-char: <<= >>= if (c === '<' && c1 === '<' && c2 === '=') return ['<<=', 3] if (c === '>' && c1 === '>' && c2 === '=') return ['>>=', 3] // 2-char if (c === '*' && c1 === '*') return ['**', 2] if (c === '<' && c1 === '<') return ['<<', 2] if (c === '>' && c1 === '>') return ['>>', 2] if (c === '=' && c1 === '=') return ['==', 2] if (c === '!' && c1 === '=') return ['!=', 2] if (c === '<' && c1 === '=') return ['<=', 2] if (c === '>' && c1 === '=') return ['>=', 2] if (c === '&' && c1 === '&') return ['&&', 2] if (c === '|' && c1 === '|') return ['||', 2] if (c === '+' && c1 === '=') return ['+=', 2] if (c === '-' && c1 === '=') return ['-=', 2] if (c === '*' && c1 === '=') return ['*=', 2] if (c === '/' && c1 === '=') return ['/=', 2] if (c === '%' && c1 === '=') return ['%=', 2] if (c === '&' && c1 === '=') return ['&=', 2] if (c === '^' && c1 === '=') return ['^=', 2] if (c === '|' && c1 === '=') return ['|=', 2] // 1-char — but NOT ++ -- (those are pre/postfix) if (c === '+' && c1 !== '+') return ['+', 1] if (c === '-' && c1 !== '-') return ['-', 1] if (c === '*') return ['*', 1] if (c === '/') return ['/', 1] if (c === '%') return ['%', 1] if (c === '<') return ['<', 1] if (c === '>') return ['>', 1] if (c === '&') return ['&', 1] if (c === '|') return ['|', 1] if (c === '^') return ['^', 1] if (c === '=') return ['=', 1] return null}
/** Precedence-climbing binary expression parser. */function parseArithBinary( P: ParseState, stop: string, minPrec: number, mode: ArithMode,): TsNode | null { let left = parseArithUnary(P, stop, mode) if (!left) return null while (true) { skipBlanks(P.L) if (isArithStop(P, stop)) break if (peek(P.L) === ',') break const opInfo = scanArithOp(P) if (!opInfo) break const [opText, opLen] = opInfo const prec = ARITH_PREC[opText] if (prec === undefined || prec < minPrec) break const os = P.L.b for (let k = 0; k < opLen; k++) advance(P.L) const op = mk(P, opText, os, P.L.b, []) const nextMin = ARITH_RIGHT_ASSOC.has(opText) ? prec : prec + 1 const right = parseArithBinary(P, stop, nextMin, mode) if (!right) break left = mk(P, 'binary_expression', left.startIndex, right.endIndex, [ left, op, right, ]) } return left}
function parseArithUnary( P: ParseState, stop: string, mode: ArithMode,): TsNode | null { skipBlanks(P.L) if (isArithStop(P, stop)) return null const c = peek(P.L) const c1 = peek(P.L, 1) // Prefix ++ -- if ((c === '+' && c1 === '+') || (c === '-' && c1 === '-')) { const s = P.L.b advance(P.L) advance(P.L) const op = mk(P, c + c1, s, P.L.b, []) const inner = parseArithUnary(P, stop, mode) if (!inner) return op return mk(P, 'unary_expression', op.startIndex, inner.endIndex, [op, inner]) } if (c === '-' || c === '+' || c === '!' || c === '~') { // In 'word'/'assign' mode (c-style for head), `-N` is a single number // literal per tree-sitter, not unary_expression. 'var' mode uses unary. if (mode !== 'var' && c === '-' && isDigit(c1)) { const s = P.L.b advance(P.L) while (isDigit(peek(P.L))) advance(P.L) return mk(P, 'number', s, P.L.b, []) } const s = P.L.b advance(P.L) const op = mk(P, c, s, P.L.b, []) const inner = parseArithUnary(P, stop, mode) if (!inner) return op return mk(P, 'unary_expression', op.startIndex, inner.endIndex, [op, inner]) } return parseArithPostfix(P, stop, mode)}
function parseArithPostfix( P: ParseState, stop: string, mode: ArithMode,): TsNode | null { const prim = parseArithPrimary(P, stop, mode) if (!prim) return null const c = peek(P.L) const c1 = peek(P.L, 1) if ((c === '+' && c1 === '+') || (c === '-' && c1 === '-')) { const s = P.L.b advance(P.L) advance(P.L) const op = mk(P, c + c1, s, P.L.b, []) return mk(P, 'postfix_expression', prim.startIndex, op.endIndex, [prim, op]) } return prim}
function parseArithPrimary( P: ParseState, stop: string, mode: ArithMode,): TsNode | null { skipBlanks(P.L) if (isArithStop(P, stop)) return null const c = peek(P.L) if (c === '(') { const s = P.L.b advance(P.L) const open = mk(P, '(', s, P.L.b, []) // Parenthesized expression may contain comma-separated exprs const inners = parseArithCommaList(P, ')', mode) skipBlanks(P.L) let close: TsNode if (peek(P.L) === ')') { const cs = P.L.b advance(P.L) close = mk(P, ')', cs, P.L.b, []) } else { close = mk(P, ')', P.L.b, P.L.b, []) } return mk(P, 'parenthesized_expression', open.startIndex, close.endIndex, [ open, ...inners, close, ]) } if (c === '"') { return parseDoubleQuoted(P) } if (c === '$') { return parseDollarLike(P) } if (isDigit(c)) { const s = P.L.b while (isDigit(peek(P.L))) advance(P.L) // Hex: 0x1f if ( P.L.b - s === 1 && c === '0' && (peek(P.L) === 'x' || peek(P.L) === 'X') ) { advance(P.L) while (isHexDigit(peek(P.L))) advance(P.L) } // Base notation: BASE#DIGITS e.g. 2#1010, 16#ff else if (peek(P.L) === '#') { advance(P.L) while (isBaseDigit(peek(P.L))) advance(P.L) } return mk(P, 'number', s, P.L.b, []) } if (isIdentStart(c)) { const s = P.L.b while (isIdentChar(peek(P.L))) advance(P.L) const nc = peek(P.L) // Assignment in 'assign' mode (c-style for init): emit variable_assignment // so chained `a = b = c = 1` nests correctly. Other modes treat `=` as a // binary_expression operator via the precedence table. if (mode === 'assign') { skipBlanks(P.L) const ac = peek(P.L) const ac1 = peek(P.L, 1) if (ac === '=' && ac1 !== '=') { const vn = mk(P, 'variable_name', s, P.L.b, []) const es = P.L.b advance(P.L) const eq = mk(P, '=', es, P.L.b, []) // RHS may itself be another assignment (chained) const val = parseArithTernary(P, stop, mode) const end = val ? val.endIndex : eq.endIndex const kids = val ? [vn, eq, val] : [vn, eq] return mk(P, 'variable_assignment', s, end, kids) } } // Subscript if (nc === '[') { const vn = mk(P, 'variable_name', s, P.L.b, []) const brS = P.L.b advance(P.L) const brOpen = mk(P, '[', brS, P.L.b, []) const idx = parseArithTernary(P, ']', 'var') ?? parseDollarLike(P) skipBlanks(P.L) let brClose: TsNode if (peek(P.L) === ']') { const cs = P.L.b advance(P.L) brClose = mk(P, ']', cs, P.L.b, []) } else { brClose = mk(P, ']', P.L.b, P.L.b, []) } const kids = idx ? [vn, brOpen, idx, brClose] : [vn, brOpen, brClose] return mk(P, 'subscript', s, brClose.endIndex, kids) } // Bare identifier: variable_name in 'var' mode, word in 'word'/'assign' mode. // 'assign' mode falls through to word when no `=` follows (c-style for // cond/update clauses: `c<=5` → binary_expression(word, number)). const identType = mode === 'var' ? 'variable_name' : 'word' return mk(P, identType, s, P.L.b, []) } return null}
function isArithStop(P: ParseState, stop: string): boolean { const c = peek(P.L) if (stop === '))') return c === ')' && peek(P.L, 1) === ')' if (stop === ')') return c === ')' if (stop === ';') return c === ';' if (stop === ':') return c === ':' if (stop === ']') return c === ']' if (stop === '}') return c === '}' if (stop === ':}') return c === ':' || c === '}' return c === '' || c === '\n'}