/*! * SomonScript 0.6.0 — compiler for browsers (40 modules). * https://lindentech.de — MIT License. * Built by scripts/build-browser.js; TypeScript is loaded separately when lowering is needed. */ (function (root, factory) { if (typeof module === 'object' && module.exports) module.exports = factory(); else root.SomonScript = factory(); })(typeof globalThis !== 'undefined' ? globalThis : this, function () { 'use strict'; // The type checker looks names up on the global object var global = typeof globalThis !== 'undefined' ? globalThis : self; var modules = { "ast.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); }, {}, ], "browser.js": [ function (module, exports, require) { "use strict"; /** * The SomonScript compiler for browsers: `compile(source, options)` and * `execute(code, console)` without Node.js built-ins (no file system, no * module system, no Babel). scripts/build-browser.js bundles this module and * the compiler stages it imports into one file. * * TypeScript is not bundled. The generated code (ES2022) runs as is for the * es2022 target (the default) and newer; TypeScript's `transpileModule` is * needed only to lower it: for decorators, `дастрасӣ` accessors and * `истифода`, which no runtime runs yet, and for older targets. Pass the * TypeScript API as `options.typescript`, or load `typescript.js` so that * `globalThis.ts` exists, before compiling such programs. Lowering uses the * TypeScript options of the Node compiler (src/targets.ts), which this module * cannot import: it loads TypeScript itself. */ Object.defineProperty(exports, "__esModule", { value: true }); exports.version = void 0; exports.compile = compile; exports.execute = execute; const codegen_1 = require("./codegen"); const problems_1 = require("./diagnostics/problems"); const warnings_1 = require("./learner/warnings"); const lexer_1 = require("./lexer"); const parser_1 = require("./parser"); const trace_generator_1 = require("./trace-generator"); const type_checker_1 = require("./type-checker"); /** The targets of src/targets.ts, oldest first. */ const TARGETS = [ 'es5', 'es2015', 'es2016', 'es2017', 'es2018', 'es2019', 'es2020', 'es2021', 'es2022', 'es2023', 'es2024', 'es2025', 'esnext', ]; /** The code generator emits ES2022: from this target on nothing needs lowering but new syntax. */ const NATIVE_FROM = TARGETS.indexOf('es2022'); function compile(source, options = {}) { const problems = new problems_1.Problems(); const result = compileProgram(source, options, problems); if (options.language === undefined) return result; const diagnostics = problems.diagnostics(source, options.language); return { ...result, ...(0, problems_1.localizedMessages)(diagnostics, source, options.language) }; } function compileProgram(source, options, problems) { const errors = []; const warnings = []; const fail = () => ({ code: '', errors, warnings }); let program; try { const parser = new parser_1.Parser(new lexer_1.Lexer(source).tokenize()); program = parser.parse(); for (const error of parser.getErrors()) { errors.push(`Parse error: ${error}`); problems.add({ kind: 'syntax', text: error }); } } catch (error) { // The lexer reports a problem with an Error; the parser collects its own errors.push(error.message); problems.add({ kind: 'syntax', text: error.message }); return fail(); } if (errors.length > 0) return fail(); if (options.typeCheck !== false) { const checked = options.learningMode ? (0, warnings_1.checkForLearners)(program, source, Boolean(options.strict)) : new type_checker_1.TypeChecker(source, { strict: Boolean(options.strict) }).check(program); errors.push(...checked.errors.map(error => `Type error [${error.code}] at line ${error.line}, column ${error.column}: ${error.message}\n> ${error.snippet}`)); warnings.push(...checked.warnings.map(warning => `Type warning [${warning.code}] at line ${warning.line}, column ${warning.column}: ${warning.message}\n> ${warning.snippet}`)); [...checked.errors, ...checked.warnings].forEach(error => problems.add({ kind: 'type', error })); if (options.strict && checked.errors.length > 0) return fail(); } const generator = codeGenerator(options); const generated = options.mappings ? generator.generateWithMappings(program) : { code: generator.generate(program), mappings: undefined }; const codegenErrors = generator.getErrors(); if (codegenErrors.length > 0) { for (const error of codegenErrors) { errors.push(`Code generation error: ${error}`); problems.add({ kind: 'codegen', text: error }); } return fail(); } const result = lower(generated.code, generator.getLoweringNeeds(), options, { errors, warnings, problems, }); // Lowered code has other positions if (generated.mappings && result.code === generated.code) result.mappings = generated.mappings; return result; } /** The code generator of the options: one that records the steps with `trace`. */ function codeGenerator(options) { const generatorOptions = { experimentalDecorators: options.experimentalDecorators }; return options.trace ? new trace_generator_1.TraceGenerator(generatorOptions) : new codegen_1.CodeGenerator(generatorOptions); } /** A `"use strict"` directive on the first line (after a `#!` line). */ const USE_STRICT = /^(#![^\n]*\n)?"use strict";\n/; /** Lowers the generated code with TypeScript when the target or the syntax needs it. */ function lower(code, needs, options, { errors, warnings, problems }) { const target = (options.target ?? 'es2022').toLowerCase(); const index = TARGETS.indexOf(target); if (index === -1) { const text = `Unknown target '${target}'. Targets: ${TARGETS.join(', ')}`; errors.push(text); problems.add({ kind: 'option', text }); return { code: '', errors, warnings }; } // Decorators, `accessor` and `using`: no runtime runs them yet const neverNative = needs.decorators || needs.parameterDecorators || needs.autoAccessors || needs.usingDeclarations; if (!neverNative && index >= NATIVE_FROM) return { code, errors, warnings }; const ts = options.typescript ?? globalTypeScript(); if (!ts) return missingTypeScript(neverNative, target, { errors, warnings, problems }); // As src/targets.ts does: TypeScript keeps decorators for ESNext, so lower them as for es2025 const lowerTo = neverNative && target === 'esnext' ? 'es2025' : target; const output = ts.transpileModule(code, { // A `.js` name: the input is JavaScript fileName: 'module.js', compilerOptions: { target: scriptTargetOf(ts, lowerTo), module: ts.ModuleKind.ESNext, allowJs: true, // TypeScript 6 deprecates both; they work without an error with `ignoreDeprecations` ...(lowerTo === 'es5' && { downlevelIteration: true, ignoreDeprecations: '6.0' }), useDefineForClassFields: index >= NATIVE_FROM, newLine: ts.NewLineKind.LineFeed, ...(options.experimentalDecorators && { experimentalDecorators: true }), }, }); return { code: keepMode(code, output.outputText), errors, warnings }; } /** The result when the code needs lowering and no TypeScript is loaded. */ function missingTypeScript(neverNative, target, { errors, warnings, problems }) { const text = neverNative ? 'This program uses decorators, accessors or `истифода`, which TypeScript lowers: load TypeScript (typescript.js) and compile again' : `The '${target}' target needs TypeScript to lower the code: load TypeScript (typescript.js) and compile again`; errors.push(text); problems.add({ kind: 'detail', id: neverNative ? 'BROWSER_NEEDS_TYPESCRIPT' : 'TARGET_UNSUPPORTED', text, }); return { code: '', errors, warnings, needsTypeScript: true }; } /** * TypeScript 6 starts every script with `"use strict"`; lowered code keeps the * mode of the generated code (as `keepSloppyMode` in src/targets.ts does). */ function keepMode(code, lowered) { return USE_STRICT.test(code) ? lowered : lowered.replace(USE_STRICT, '$1'); } /** * `ts.ScriptTarget` of a target: 'es2017' → ES2017. The page may load another * TypeScript than the one the compiler is built with: a target newer than it * knows (es2025 before TypeScript 6) uses the newest older one. Never * 'esnext', which needs no lowering but of what no runtime runs (lowered as * for es2025). */ function scriptTargetOf(ts, target) { for (let index = TARGETS.indexOf(target); index > 0; index--) { const value = ts.ScriptTarget[TARGETS[index].toUpperCase()]; if (typeof value === 'number') return value; } return ts.ScriptTarget.ES5; } function globalTypeScript() { // `global` is the global object in Node.js; the browser bundle defines it as `globalThis` const candidate = global.ts; return candidate && typeof candidate.transpileModule === 'function' ? candidate : undefined; } /** * Runs compiled code with the given console. The code runs as a CommonJS * module (`module.exports` is returned); `require` of other modules is not * available in the browser. Exceptions propagate to the caller. */ function execute(code, consoleLike) { const module = { exports: {} }; const require = (id) => { throw new Error(`Cannot load the module '${id}': modules are not available in the browser`); }; // Running the compiled program is what this function is for const run = new Function('console', 'require', 'module', 'exports', code); // NOSONAR run(consoleLike, require, module, module.exports); // NOSONAR: runs the user's own program (S1523) return module.exports; } /** The compiler version, filled in by the browser build. */ exports.version = '0.6.0'; }, {"./codegen":"codegen.js","./diagnostics/problems":"diagnostics/problems.js","./learner/warnings":"learner/warnings.js","./lexer":"lexer.js","./parser":"parser.js","./trace-generator":"trace-generator.js","./type-checker":"type-checker.js"}, ], "builtin-globals.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.isCheckedBuiltinObject = isCheckedBuiltinObject; exports.builtinObjectMemberName = builtinObjectMemberName; exports.builtinObjectHasMember = builtinObjectHasMember; exports.builtinObjectMemberNames = builtinObjectMemberNames; exports.isNotCallableBuiltin = isNotCallableBuiltin; /** * The built-in objects SomonScript names in Tajik (`чоп`, `математика`, `Риёзӣ`): * which members they have, so the type checker reports `чоп.сабтт(…)` or * `математика.решаа(…)` before the program runs, and which of them cannot be * called (`математика(…)`). */ const builtin_names_1 = require("./builtin-names"); /** The console methods of the Console Standard and Node.js. */ const CONSOLE_METHODS = new Set([ 'assert', 'clear', 'count', 'countReset', 'debug', 'dir', 'dirxml', 'error', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log', 'profile', 'profileEnd', 'table', 'time', 'timeEnd', 'timeLog', 'timeStamp', 'trace', 'warn', ]); /** The object each Tajik name stands for, as the code generator emits it (`mapBuiltinObject`). */ const BUILTIN_OBJECTS = new Map([ ['чоп', console], ['математика', Math], ['Риёзӣ', Math], ]); /** Built-in objects that are not functions: calling one always fails. */ const NOT_CALLABLE = new Set(['математика', 'Риёзӣ']); /** Whether `name` is a built-in object whose members are checked. */ function isCheckedBuiltinObject(name) { return BUILTIN_OBJECTS.has(name); } /** * JavaScript name of member `member` of built-in object `objectName`: every * Tajik alias is translated there (`математика.поён` → `Math.floor`), and * `чоп.Хато` is `console.error`, as `чоп.хато` is. */ function builtinObjectMemberName(objectName, member) { const jsName = builtin_names_1.BUILTIN_MAPPINGS.get(member) ?? member; return objectName === 'чоп' && jsName === 'Error' ? 'error' : jsName; } /** Whether built-in object `objectName` (one of `isCheckedBuiltinObject`) has `member`. */ function builtinObjectHasMember(objectName, member) { const jsName = builtinObjectMemberName(objectName, member); const object = BUILTIN_OBJECTS.get(objectName); if (objectName === 'чоп' && CONSOLE_METHODS.has(jsName)) return true; return jsName in object; } /** The Tajik names of the members of a built-in object, for "did you mean". */ function builtinObjectMemberNames(objectName) { return [...builtin_names_1.BUILTIN_MAPPINGS.keys()].filter(name => /^[\u0400-\u04ff]/.test(name) && builtinObjectHasMember(objectName, name)); } /** Whether `name` is a built-in object that cannot be called (`математика(…)`). */ function isNotCallableBuiltin(name) { return NOT_CALLABLE.has(name); } }, {"./builtin-names":"builtin-names.js"}, ], "builtin-names.js": [ function (module, exports, require) { "use strict"; /** * Tajik names of JavaScript built-ins shared by the code generator and the * type checker. */ Object.defineProperty(exports, "__esModule", { value: true }); exports.BUILTIN_MAPPINGS = exports.MEMBER_ALIASES = void 0; exports.translateMemberName = translateMemberName; /** * Built-in member names that are translated wherever a member name appears — * `о.дарозӣ`, `{ дарозӣ: 1 }`, class members and destructuring keys alike — so * a user-defined member with such a name stays consistent between declaration * and use. */ exports.MEMBER_ALIASES = new Set([ // Console methods 'сабт', 'хато', 'огоҳӣ', 'маълумот', 'исфти', 'тасдиқ', 'ҷадвал', 'гуруҳ', 'гуруҳОхир', 'гуруҳПӯшида', 'вақт', 'вақтОхир', 'вақтСабт', 'қайд', 'қайдАсл', 'полиз', 'феҳрист', 'xmlФеҳрист', 'пайҷо', // Array methods 'дарозӣ', 'дар', 'пайвастан', 'нусхаДарДохил', 'воридот', 'ҳама', 'пурКардан', 'филтр', 'кофтан', 'индексиЁфтан', 'охиринЁфтан', 'индексиОхиринЁфтан', 'ҳамвор', 'ҳамворХарита', 'бароиҲар', 'аз', 'дорад', 'индекси', 'рӯйхатАст', 'пайвастКардан', 'калидҳо', 'индексиОхирин', 'харита', 'азАргументҳо', 'баровардан', 'илова', 'пуш', 'ҷамъбаст', 'ҷамъбастАзРост', 'баргардон', 'ҳазфиАввал', 'буридан', 'баъзе', 'тартиб', 'пайваст', 'баСатриМаҳаллӣ', 'баБаргардон', 'баТартиб', 'баПайваст', 'баСатр', 'иловаБаАввал', 'қиматҳо', 'бо', // String methods 'дарозииСатр', 'аломатДар', 'кодиАломатДар', 'нуқтаиКодДар', 'анҷомБо', 'азКодиАломат', 'азНуқтаиКод', 'муқоисаиМаҳаллӣ', 'мувофиқат', 'мувофиқатҲама', 'муқаррарӣ', 'пурКарданОхир', 'пурКарданАввал', 'хоми', 'такрор', 'ҷойивазкунӣ', 'ҷойгузин', 'ҷойивазкунӣҲама', 'ҷустуҷӯ', 'ҷудокунӣ', 'оғозБо', 'қисмат', 'хурдМаҳаллӣ', 'калонМаҳаллӣ', 'хурд', 'калон', 'тозаКардан', 'тозаКарданОхир', 'тозаКарданАввал', 'қиматиАслӣ', // Math methods 'Е', 'ЛН10', 'ЛН2', 'ЛОГ10Е', 'ЛОГ2Е', 'ПИ', 'РЕША1_2', 'РЕША2', 'мутлақ', 'арккосинус', 'арккосинусГиперболӣ', 'арксинус', 'арксинусГиперболӣ', 'арктангенс', 'арктангенс2', 'арктангенсГиперболӣ', 'решаиКубӣ', 'боло', 'clz32', 'косинус', 'косинусГиперболӣ', 'экспонента', 'expm1', 'поён', 'fround', 'гипотенуза', 'imul', 'логарифм', 'логарифм10', 'логарифм1п', 'логарифм2', 'ҳаддиАксар', 'ҳаддиАқал', 'қувват', 'тасодуфӣ', 'дузкунӣ', 'аломат', 'синус', 'синусГиперболӣ', 'дуръшака', 'тангенс', 'тангенсГиперболӣ', 'бириданАдад', // Object methods 'таъин', 'сохтан', 'муайянХосиятҳо', 'муайянХосият', 'яхКардан', 'азВоридот', 'тавсифиХосият', 'тавсифиХосиятҳо', 'номҳоиХосият', 'рамзҳоиХосият', 'прототип', 'гурӯҳбандӣ', 'дорадХосият', 'аст', 'васеъшаванда', 'яхшуда', 'мӯҳршуда', 'манъиВасеъшавӣ', 'мӯҳр', 'танзимиПрототип', // Map / Set methods 'бозгирифтан', 'гузоштан', 'дорадКалид', 'ҳаҷм', 'нобудКардан', ]); /** Tajik built-in names and their JavaScript equivalents. */ exports.BUILTIN_MAPPINGS = new Map([ // Console functions ['чоп', 'console'], ['сабт', 'log'], ['хато', 'error'], ['огоҳӣ', 'warn'], ['маълумот', 'info'], ['исфти', 'debug'], ['ҷадвал', 'table'], ['гуруҳ', 'group'], ['гуруҳОхир', 'groupEnd'], ['гуруҳПӯшида', 'groupCollapsed'], ['вақт', 'time'], ['вақтОхир', 'timeEnd'], ['вақтСабт', 'timeLog'], ['қайд', 'count'], ['қайдАсл', 'countReset'], ['тасдиқ', 'assert'], ['полиз', 'clear'], ['феҳрист', 'dir'], ['xmlФеҳрист', 'dirxml'], ['пайҷо', 'trace'], // Error handling ['Хато', 'Error'], // Map / Set methods ['бозгирифтан', 'get'], ['гузоштан', 'set'], ['дорадКалид', 'has'], ['ҳаҷм', 'size'], ['нобудКардан', 'delete'], // Array methods ['рӯйхат', 'Array'], ['дарозӣ', 'length'], ['дар', 'at'], ['пайвастан', 'concat'], ['нусхаДарДохил', 'copyWithin'], ['воридот', 'entries'], ['ҳама', 'every'], ['пурКардан', 'fill'], ['филтр', 'filter'], ['кофтан', 'find'], ['индексиЁфтан', 'findIndex'], ['охиринЁфтан', 'findLast'], ['индексиОхиринЁфтан', 'findLastIndex'], ['ҳамвор', 'flat'], ['ҳамворХарита', 'flatMap'], ['бароиҲар', 'forEach'], ['аз', 'from'], ['дорад', 'includes'], ['индекси', 'indexOf'], ['рӯйхатАст', 'isArray'], ['пайвастКардан', 'join'], ['калидҳо', 'keys'], ['индексиОхирин', 'lastIndexOf'], ['харита', 'map'], ['азАргументҳо', 'of'], ['баровардан', 'pop'], ['илова', 'push'], ['пуш', 'push'], ['ҷамъбаст', 'reduce'], ['ҷамъбастАзРост', 'reduceRight'], ['баргардон', 'reverse'], ['ҳазфиАввал', 'shift'], ['буридан', 'slice'], ['баъзе', 'some'], ['тартиб', 'sort'], ['пайваст', 'splice'], ['баСатриМаҳаллӣ', 'toLocaleString'], ['баБаргардон', 'toReversed'], ['баТартиб', 'toSorted'], ['баПайваст', 'toSpliced'], ['баСатр', 'toString'], ['иловаБаАввал', 'unshift'], ['қиматҳо', 'values'], ['бо', 'with'], // String methods ['сатр', 'String'], // String type/constructor ['сатрМетодҳо', 'String'], // String methods object ['дарозииСатр', 'length'], ['дар', 'at'], ['аломатДар', 'charAt'], ['кодиАломатДар', 'charCodeAt'], ['нуқтаиКодДар', 'codePointAt'], ['пайвастан', 'concat'], ['анҷомБо', 'endsWith'], ['азКодиАломат', 'fromCharCode'], ['азНуқтаиКод', 'fromCodePoint'], ['дорад', 'includes'], ['индекси', 'indexOf'], ['индексиОхирин', 'lastIndexOf'], ['муқоисаиМаҳаллӣ', 'localeCompare'], ['мувофиқат', 'match'], ['мувофиқатҲама', 'matchAll'], ['муқаррарӣ', 'normalize'], ['пурКарданОхир', 'padEnd'], ['пурКарданАввал', 'padStart'], ['хоми', 'raw'], ['такрор', 'repeat'], ['ҷойивазкунӣ', 'replace'], ['ҷойгузин', 'replace'], ['ҷойивазкунӣҲама', 'replaceAll'], ['ҷустуҷӯ', 'search'], ['буридан', 'slice'], ['ҷудокунӣ', 'split'], ['оғозБо', 'startsWith'], ['қисмат', 'substring'], ['хурдМаҳаллӣ', 'toLocaleLowerCase'], ['калонМаҳаллӣ', 'toLocaleUpperCase'], ['хурд', 'toLowerCase'], ['баСатр', 'toString'], ['калон', 'toUpperCase'], ['тозаКардан', 'trim'], ['тозаКарданОхир', 'trimEnd'], ['тозаКарданАввал', 'trimStart'], ['қиматиАслӣ', 'valueOf'], // Object methods ['объект', 'Object'], ['таъин', 'assign'], ['сохтан', 'create'], ['муайянХосиятҳо', 'defineProperties'], ['муайянХосият', 'defineProperty'], ['воридот', 'entries'], ['яхКардан', 'freeze'], ['азВоридот', 'fromEntries'], ['тавсифиХосият', 'getOwnPropertyDescriptor'], ['тавсифиХосиятҳо', 'getOwnPropertyDescriptors'], ['номҳоиХосият', 'getOwnPropertyNames'], ['рамзҳоиХосият', 'getOwnPropertySymbols'], ['прототип', 'getPrototypeOf'], ['гурӯҳбандӣ', 'groupBy'], ['дорадХосият', 'hasOwn'], ['аст', 'is'], ['васеъшаванда', 'isExtensible'], ['яхшуда', 'isFrozen'], ['мӯҳршуда', 'isSealed'], ['калидҳо', 'keys'], ['манъиВасеъшавӣ', 'preventExtensions'], ['мӯҳр', 'seal'], ['танзимиПрототип', 'setPrototypeOf'], ['қиматҳо', 'values'], // Math ['математика', 'Math'], ['Риёзӣ', 'Math'], ['Е', 'E'], ['ЛН10', 'LN10'], ['ЛН2', 'LN2'], ['ЛОГ10Е', 'LOG10E'], ['ЛОГ2Е', 'LOG2E'], ['ПИ', 'PI'], ['РЕША1_2', 'SQRT1_2'], ['РЕША2', 'SQRT2'], ['мутлақ', 'abs'], ['арккосинус', 'acos'], ['арккосинусГиперболӣ', 'acosh'], ['арксинус', 'asin'], ['арксинусГиперболӣ', 'asinh'], ['арктангенс', 'atan'], ['арктангенс2', 'atan2'], ['арктангенсГиперболӣ', 'atanh'], ['решаиКубӣ', 'cbrt'], ['боло', 'ceil'], ['clz32', 'clz32'], ['косинус', 'cos'], ['косинусГиперболӣ', 'cosh'], ['экспонента', 'exp'], ['expm1', 'expm1'], ['поён', 'floor'], ['fround', 'fround'], ['гипотенуза', 'hypot'], ['imul', 'imul'], ['логарифм', 'log'], ['логарифм10', 'log10'], ['логарифм1п', 'log1p'], ['логарифм2', 'log2'], ['ҳаддиАксар', 'max'], ['ҳаддиАқал', 'min'], ['қувват', 'pow'], ['тасодуфӣ', 'random'], ['дузкунӣ', 'round'], ['аломат', 'sign'], ['синус', 'sin'], ['синусГиперболӣ', 'sinh'], ['дуръшака', 'sqrt'], ['тангенс', 'tan'], ['тангенсГиперболӣ', 'tanh'], ['бириданАдад', 'trunc'], // Control flow ['шикастан', 'break'], ['давом', 'continue'], ['кӯшиш', 'try'], // Async/Promise ['ваъда', 'Promise'], ['Ваъда', 'Promise'], ['гирифтан', 'catch'], ['ниҳоят', 'finally'], ['партофтан', 'throw'], // Async ['ҳамзамон', 'async'], ['интизор', 'await'], ['ваъда', 'Promise'], // Note: 'хато' is handled specially in generateIdentifier ]); /** JavaScript name of a member name: `дарозӣ` → `length`, other names unchanged. */ function translateMemberName(name) { // Every member alias has a mapping (tests/builtin-names.test.ts) return exports.MEMBER_ALIASES.has(name) ? exports.BUILTIN_MAPPINGS.get(name) : name; } }, {}, ], "codegen.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.CodeGenerator = exports.PREC = void 0; exports.originalPosition = originalPosition; exports.stripPositionMarkers = stripPositionMarkers; const builtin_names_1 = require("./builtin-names"); /** Precedence levels of non-binary expressions; binary levels live in `operatorPrecedence`. */ exports.PREC = { SEQUENCE: 1, ASSIGNMENT: 2, CONDITIONAL: 3, /** Relational operators (`<`, `in`, …); TypeScript's `as` and `satisfies` bind like them. */ RELATIONAL: 11, UNARY: 16, POSTFIX: 17, CALL: 19, PRIMARY: 20, }; /** * The `.som` position (line 1-based, column 0-based) of a position in the * generated code: that of the nearest mapping at or before it. */ function originalPosition(mappings, line, column) { let low = 0; let high = mappings.length - 1; let found = -1; while (low <= high) { const middle = Math.floor((low + high) / 2); const generated = mappings[middle].generated; if (generated.line < line || (generated.line === line && generated.column <= column)) { found = middle; low = middle + 1; } else { high = middle - 1; } } return found === -1 ? undefined : mappings[found].original; } const POSITION_MARKER = '\0'; /** Removes position markers (see `generateWithMappings`) from generated text. */ function stripPositionMarkers(code) { return code.includes(POSITION_MARKER) ? code.replace(/\0[^\0]*\0/g, '') : code; } /** AST keys that hold types, which are erased from JavaScript. */ const TYPE_KEYS = new Set([ 'typeAnnotation', 'returnType', 'typeParameters', 'typeArguments', 'superTypeArguments', 'implements', 'implementsTypeArguments', ]); /** Words that are not valid JavaScript identifiers (strict mode, CommonJS output). */ const JS_RESERVED_WORDS = new Set([ 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export', 'extends', 'false', 'finally', 'for', 'function', 'if', 'implements', 'import', 'in', 'instanceof', 'interface', 'let', 'new', 'null', 'package', 'private', 'protected', 'public', 'return', 'static', 'super', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with', 'yield', ]); /** Reserved words that are themselves complete JavaScript expressions. */ const JS_KEYWORD_EXPRESSIONS = new Set([ 'null', 'true', 'false', 'this', 'super', ]); /** * Expressions that only assert a type (`х чун Т`, `<Т>х`, `х бармесоё Т`, `х!`) * or fix type arguments (`ф<Т>`). */ const ASSERTION_TYPES = new Set([ 'AsExpression', 'TypeAssertion', 'SatisfiesExpression', 'NonNullExpression', 'InstantiationExpression', ]); /** Declarations without a runtime value: exporting one as default exports no value. */ const TYPE_ONLY_DECLARATIONS = new Set([ 'InterfaceDeclaration', 'TypeAlias', 'FunctionSignature', ]); /** Spellings of the default export's name: `содир { х чун пешфарз }`. */ const DEFAULT_NAMES = new Set(['default', 'пешфарз']); /** `code` without the line breaks at its end (a loop, not a backtracking `/\n+$/`). */ function withoutTrailingNewlines(code) { let end = code.length; while (end > 0 && code[end - 1] === '\n') end--; return code.slice(0, end); } /** Types are erased: an assertion is emitted as the expression it wraps. */ function skipAssertions(node) { let current = node; while (current && ASSERTION_TYPES.has(current.type)) { current = current.expression; } return current; } const NODE_PRECEDENCE = { SequenceExpression: exports.PREC.SEQUENCE, AssignmentExpression: exports.PREC.ASSIGNMENT, ArrowFunctionExpression: exports.PREC.ASSIGNMENT, ConditionalExpression: exports.PREC.CONDITIONAL, UnaryExpression: exports.PREC.UNARY, AwaitExpression: exports.PREC.UNARY, CallExpression: exports.PREC.CALL, MemberExpression: exports.PREC.CALL, TaggedTemplateExpression: exports.PREC.CALL, NewExpression: exports.PREC.CALL, ImportExpression: exports.PREC.CALL, YieldExpression: exports.PREC.ASSIGNMENT, }; /** * The input functions of a program that reads input (`хондан`, * `хонданиРақам`): the run time of `somon run` and the playground provide them * (src/runtime/input.ts); elsewhere a call says where they work. */ const INPUT_PROLOGUE = [ 'const { хондан, хонданиРақам } = globalThis.__somonInput || {', ' хондан: __somonNoInput,', ' хонданиРақам: __somonNoInput,', '};', 'function __somonNoInput() {', ' throw new Error("хондан() and хонданиРақам() read input when the program runs with \'somon run\' or in the playground");', '}', ].join('\n'); /** The names of the input functions. */ const INPUT_FUNCTIONS = new Set(['хондан', 'хонданиРақам']); /** * The namespace of a deferred import (`ворид мавқуф * чун Н аз "./м";`) in * CommonJS output: the module is required when one of its members is first * read (`Н.х`, `"х" дар Н`, `Object.keys(Н)`), as `import defer` (TypeScript * 5.9) runs a module. `then` and symbols do not run it, so that a promise can * resolve to the namespace (`ворид.мавқуф(…)`); its members are read-only. * Written in ES5 syntax for every target; it needs `Proxy` and `Reflect`. */ const DEFER_HELPER = [ 'function __somonDefer(load) {', ' var loaded;', ' var target = Object.create(null);', ' function exports() {', ' if (!loaded) {', ' loaded = { value: load() };', ' Object.assign(target, loaded.value);', ' }', ' return loaded.value;', ' }', ' function passive(key) {', " return typeof key === 'symbol' || key === 'then';", ' }', ' return new Proxy(target, {', ' get: function (_, key) {', ' return passive(key) ? undefined : Reflect.get(exports(), key);', ' },', ' has: function (_, key) {', ' return !passive(key) && Reflect.has(exports(), key);', ' },', ' ownKeys: function () {', ' return Reflect.ownKeys(exports());', ' },', ' getOwnPropertyDescriptor: function (_, key) {', ' if (passive(key)) return undefined;', ' var descriptor = Reflect.getOwnPropertyDescriptor(exports(), key);', ' if (descriptor) descriptor.configurable = true;', ' return descriptor;', ' },', ' set: function () {', ' return false;', ' },', ' defineProperty: function () {', ' return false;', ' },', ' deleteProperty: function () {', ' return false;', ' }', ' });', '}', ].join('\n'); /** An identifier name of JavaScript: the property after `.`. */ const IDENTIFIER_NAME = /^[\p{ID_Start}$_][\p{ID_Continue}$\u200c\u200d]*$/u; /** Statements `давом` may continue: the loops. */ const LOOP_TYPES = new Set([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement', ]); class CodeGenerator { constructor(options = {}) { this.indentLevel = 0; this.indentSize = 2; this.importCounter = 0; this.errors = []; /** Names declared by the program, innermost scope last (see `withScope`). */ this.scopes = []; /** Enclosing loops and `интихоб` statements of the current function, for `шикастан`/`давом`. */ this.jumpTargets = { loops: 0, switches: 0 }; /** Whether statements are prefixed with position markers (`generateWithMappings`). */ this.trackPositions = false; /** Function bodies around the current node; 0 at the top level of the module. */ this.functionDepth = 0; /** ES module output: local names exported so far (an ES module exports a name once). */ this.esmExportedNames = new Set(); /** Labels around the current statement in the current function, innermost last. */ this.labels = []; /** Whether the current function is `ҳамзамон` (allows `барои интизор`). */ this.inAsyncFunction = false; /** Enclosing non-arrow functions and class bodies, where `нав.target` is allowed. */ this.newTargetScopes = 0; /** Private names (`#ном`, without '#') declared by each enclosing class, innermost last. */ this.privateNames = []; /** Inside a class `статикӣ { … }` block (and not in a function within it). */ this.inStaticBlock = false; /** What `ts.transpileModule` must lower in the generated code (see `getLoweringNeeds`). */ this.lowering = CodeGenerator.noLowering(); /** CommonJS output defers an import, with `__somonDefer` (see `DEFER_HELPER`). */ this.usesDeferHelper = false; /** The program reads input with `хондан`/`хонданиРақам` it does not declare. */ this.usesInput = false; /** Declarations that merge with others of their name (namespaces, enums). */ this.mergeGroups = new WeakMap(); // Operator precedence table (higher number = higher precedence = evaluated first) // Based on JavaScript operator precedence: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence this.operatorPrecedence = new Map([ // Comma (lowest precedence) [',', 1], // Assignment operators ['=', 2], ['+=', 2], ['-=', 2], ['*=', 2], ['/=', 2], ['%=', 2], ['**=', 2], ['<<=', 2], ['>>=', 2], ['>>>=', 2], ['&=', 2], ['^=', 2], ['|=', 2], ['&&=', 2], ['||=', 2], ['??=', 2], // Conditional (ternary) ['?', 3], // Nullish coalescing ['??', 4], // Logical OR ['||', 5], // Logical AND ['&&', 6], // Bitwise OR ['|', 7], // Bitwise XOR ['^', 8], // Bitwise AND ['&', 9], // Equality operators ['==', 10], ['!=', 10], ['===', 10], ['!==', 10], // Relational operators ['<', 11], ['<=', 11], ['>', 11], ['>=', 11], ['in', 11], ['instanceof', 11], // Bitwise shift ['<<', 12], ['>>', 12], ['>>>', 12], // Additive ['+', 13], ['-', 13], // Multiplicative ['*', 14], ['/', 14], ['%', 14], // Exponentiation (right-associative, highest precedence for binary operators) ['**', 15], ]); /** The generator of each type of expression; type assertions are handled before. */ this.expressionGenerators = new Map([ ['Identifier', node => this.generateIdentifier(node)], ['Literal', node => this.generateLiteral(node)], // Pattern and flags as written; the lexer has validated them [ 'RegExpLiteral', node => `/${node.pattern}/${node.flags}`, ], ['TemplateLiteral', node => this.generateTemplateLiteral(node)], ['ThisExpression', () => 'this'], ['Super', () => 'super'], ['MetaProperty', node => this.generateNewTarget(node)], ['PrivateIdentifier', node => this.generatePrivateIdentifier(node)], ['BinaryExpression', node => this.generateBinaryExpression(node)], ['UnaryExpression', node => this.generateUnaryExpression(node)], ['UpdateExpression', node => this.generateUpdateExpression(node)], [ 'ConditionalExpression', node => this.generateConditionalExpression(node), ], [ 'SequenceExpression', node => this.generateArguments(node.expressions), ], ['CallExpression', node => this.generateCallExpression(node)], [ 'AssignmentExpression', node => this.generateAssignmentExpression(node), ], ['MemberExpression', node => this.generateMemberExpression(node)], // The parentheses end the optional chain: `(о?.а).б`, `(о?.ф)()` [ 'ChainExpression', node => `(${this.generateExpression(node.expression)})`, ], [ 'TaggedTemplateExpression', node => this.generateTaggedTemplate(node), ], ['ArrayExpression', node => this.generateArrayExpression(node)], ['ObjectExpression', node => this.generateObjectExpression(node)], ['AwaitExpression', node => this.generateAwaitExpression(node)], ['NewExpression', node => this.generateNewExpression(node)], ['ImportExpression', node => this.generateImportExpression(node)], [ 'ArrowFunctionExpression', node => this.generateArrowFunctionExpression(node), ], ['FunctionExpression', node => this.generateFunctionExpression(node)], ['YieldExpression', node => this.generateYieldExpression(node)], ['ClassExpression', node => this.generateClassExpression(node)], ]); this.experimentalDecorators = Boolean(options.experimentalDecorators); this.topLevelAwait = Boolean(options.topLevelAwait); this.module = options.module ?? 'commonjs'; this.isDirectoryImport = options.isDirectoryImport; } static noLowering() { return { decorators: false, parameterDecorators: false, autoAccessors: false, usingDeclarations: false, }; } /** TypeScript syntax in the code generated last, which the compiler lowers. */ getLoweringNeeds() { return { ...this.lowering }; } /** * Return diagnostics collected during generation. Codegen follows the same * never-throw contract as the rest of the pipeline — unknown AST nodes are * recorded here rather than thrown. */ getErrors() { return [...this.errors]; } generate(ast) { return this.generateProgram(ast); } /** * Generate code and record, for every emitted statement, where it starts in * the output and in the SomonScript source (`line` 1-based, `column` * 0-based, as in source maps). */ generateWithMappings(ast) { this.trackPositions = true; try { return CodeGenerator.extractPositionMarkers(this.generateProgram(ast)); } finally { this.trackPositions = false; } } /** * Position markers (`\0line,column\0`) are placed in front of statements * while generating, since statement text is still re-indented and spliced * afterwards. NUL never occurs otherwise: literals escape it. */ static extractPositionMarkers(marked) { const parts = marked.split(POSITION_MARKER); const mappings = []; let code = ''; let line = 1; let column = 0; parts.forEach((part, index) => { if (index % 2 === 1) { const [originalLine, originalColumn] = part.split(',').map(Number); mappings.push({ generated: { line, column }, original: { line: originalLine, column: originalColumn }, }); return; } code += part; const lastNewline = part.lastIndexOf('\n'); if (lastNewline === -1) { column += part.length; } else { line += part.split('\n').length - 1; column = part.length - lastNewline - 1; } }); return { code, mappings }; } generateProgram(node) { this.lowering = CodeGenerator.noLowering(); this.usesDeferHelper = false; this.usesInput = false; this.esmExportedNames = new Set(); if (this.module === 'esm' && this.elidesTypes()) { this.valueNames = CodeGenerator.collectValueNames(node); this.typeOnlyNames = this.collectTypeOnlyNames(node.body); } this.checkRedeclarations(node.body); this.checkDefaultExports(node.body); const statements = this.withScope(this.declaredNames(node.body), () => [ ...this.generateStatements(node.body), ...this.programEpilogue(), ]); statements.unshift(...this.programPrologue()); if (this.usesDeferHelper) statements.unshift(DEFER_HELPER); if (this.usesInput) statements.unshift(this.inputPrologue()); // A module is strict mode code; in CommonJS (as in TypeScript's output) only by the directive if (this.module === 'commonjs' && statements.length > 0 && CodeGenerator.isModule(node.body)) { statements.unshift('"use strict";'); } // `#!/usr/bin/env node` stays the first line if (node.shebang !== undefined) statements.unshift(node.shebang); return statements.join('\n'); } /** Where a program that reads input gets `хондан` and `хонданиРақам` (see `INPUT_PROLOGUE`). */ inputPrologue() { return INPUT_PROLOGUE; } /** Statements a subclass puts before the program's own (src/trace-generator.ts). */ programPrologue() { return []; } /** Statements a subclass puts after the program's own, in its scope. */ programEpilogue() { return []; } /** The statements of a program, block or `ҳолат` arm, without the empty ones. */ generateStatements(statements) { return statements.map(stmt => this.generateStatement(stmt)).filter(stmt => stmt.length > 0); } /** * The test of an `агар`, `то`, `кун … то` or `барои` as it is emitted; a * subclass may wrap it (src/trace-generator.ts records each test). */ generateTest(_test, code) { return code; } /** * Whether a program is a module: it imports or exports (also `ворид х = * require(…)` and `содир = …`), as TypeScript decides it. */ static isModule(body) { return body.some(stmt => stmt.type === 'ImportDeclaration' || stmt.type === 'ExportDeclaration' || stmt.type === 'ExportAssignment' || (stmt.type === 'ImportEqualsDeclaration' && stmt.source !== undefined)); } /** * Whether ES module output drops what exists only as types: type-only * imports and exports (`ворид навъ`, `содир навъ`) and imports used only as * types. True for JavaScript, where they would name exports that do not * exist at run time; TypeScript output keeps them all. */ elidesTypes() { return true; } /** * Names an AST references outside of types: every identifier except those * under type keys (annotations, type arguments, `татбиқ`), in interfaces and * type aliases, and the names after `.` / object keys. Over-approximates * (declared names count too), which only keeps an import that is unused. */ static collectValueNames(root) { const names = new Set(); const visit = (value, key) => { if (Array.isArray(value)) { value.forEach(item => visit(item)); return; } if (!value || typeof value !== 'object') return; const node = value; if (CodeGenerator.isTypeOnlyNode(node)) return; if (node.type === 'Identifier' && key !== 'skip') names.add(String(node.name)); for (const [childKey, child] of Object.entries(node)) { if (TYPE_KEYS.has(childKey) || childKey === 'exported') continue; // `о.ном`, `{ ном: … }`: the name is a member name, not a reference const isMemberName = (childKey === 'property' || childKey === 'key') && node.computed !== true; visit(child, isMemberName ? 'skip' : childKey); } }; visit(root); return names; } /** * Nodes without runtime code, whose names are no value references: * interfaces, type aliases, imports, `эълон …` declarations, overload * signatures, `эълон модул` and type-only exports (`содир навъ`). */ static isTypeOnlyNode(node) { switch (node.type) { case 'InterfaceDeclaration': case 'TypeAlias': case 'ImportDeclaration': case 'FunctionSignature': case 'AmbientModuleDeclaration': return true; case 'ImportEqualsDeclaration': return node.importKind === 'type'; case 'ExportDeclaration': case 'ExportSpecifier': return node.exportKind === 'type'; default: return node.declare === true; } } /** * Top-level names that are only types: `интерфейс И`, `навъ Т` without a * value `И`/`Т`, and type-only imports (`ворид навъ { Т }`, `{ навъ Т }`). */ collectTypeOnlyNames(statements) { const types = new Set(); const values = []; for (const stmt of statements) { const declaration = stmt.type === 'ExportDeclaration' ? stmt.declaration : stmt; if (declaration?.type === 'InterfaceDeclaration' || declaration?.type === 'TypeAlias') { types.add(declaration.name.name); } else if (declaration?.type === 'ImportDeclaration') { const imports = declaration; for (const spec of imports.specifiers) { const typeOnly = imports.importKind === 'type' || spec.importKind === 'type'; if (typeOnly) types.add(spec.local.name); else values.push(spec.local.name); } } else if (declaration?.type === 'ImportEqualsDeclaration' && declaration.importKind === 'type') { types.add(declaration.id.name); } else { this.collectDeclaredNames(declaration, values); } } return new Set([...types].filter(name => !values.includes(name))); } generateStatement(node) { const code = this.generateStatementNode(node); if (!this.trackPositions || code.length === 0 || node.type === 'BlockStatement') { return code; } const marker = this.positionMarker(node); return code.replace(/^ */, indentation => indentation + marker); } // eslint-disable-next-line complexity generateStatementNode(node) { // `эълон …` declares what exists elsewhere: nothing to emit if (node.declare) return ''; switch (node.type) { case 'FunctionSignature': case 'AmbientModuleDeclaration': // Overload signatures and `эълон модул` / `эълон глобалӣ` are types only return ''; case 'ImportEqualsDeclaration': return this.generateImportEquals(node); case 'ExportAssignment': return this.generateExportAssignment(node); case 'ImportDeclaration': return this.generateImportDeclaration(node); case 'ExportDeclaration': return this.generateExportDeclaration(node); case 'VariableDeclaration': return this.generateVariableDeclaration(node); case 'VariableDeclarationList': return this.generateVariableDeclarationList(node); case 'FunctionDeclaration': return this.generateFunctionDeclaration(node); case 'BlockStatement': // A bare block opens on its own line, at the statement's indentation return this.indent(this.generateBlockStatement(node)); case 'ReturnStatement': return this.generateReturnStatement(node); case 'IfStatement': return this.generateIfStatement(node); case 'WhileStatement': return this.withJumpTarget('loops', () => this.generateWhileStatement(node)); case 'DoWhileStatement': return this.withJumpTarget('loops', () => this.generateDoWhileStatement(node)); case 'LabeledStatement': return this.generateLabeledStatement(node); case 'EmptyStatement': // Nothing to run; a body that is only `;` becomes `{}` return ''; case 'DebuggerStatement': return this.indent('debugger;'); case 'EnumDeclaration': return this.generateEnumDeclaration(node); // A loop head binding one name twice (`барои (собит [а, а] аз …)`) is an early error case 'ForStatement': if (node.init) { this.checkRedeclarations([node.init]); } return this.withScope(this.declaredNames([node.init]), () => this.withJumpTarget('loops', () => this.generateForStatement(node))); case 'ForInStatement': this.checkRedeclarations([node.left]); return this.withScope(this.declaredNames([node.left]), () => this.withJumpTarget('loops', () => this.generateForInStatement(node))); case 'ForOfStatement': if (node.await && !this.inAsyncFunction && !this.allowsTopLevelAwait()) { this.errors.push(`Illegal for await statement at line ${node.line}, column ${node.column}: 'барои интизор' must be inside a 'ҳамзамон' function`); } this.checkRedeclarations([node.left]); return this.withScope(this.declaredNames([node.left]), () => this.withJumpTarget('loops', () => this.generateForOfStatement(node))); case 'ExpressionStatement': return this.generateExpressionStatement(node); case 'TryStatement': return this.generateTryStatement(node); case 'ThrowStatement': return this.generateThrowStatement(node); case 'InterfaceDeclaration': return this.generateInterfaceDeclaration(node); case 'TypeAlias': return this.generateTypeAlias(node); case 'NamespaceDeclaration': return this.generateNamespaceDeclaration(node); case 'ClassDeclaration': return this.generateClassDeclaration(node); case 'SwitchStatement': { // All `ҳолат` arms share one scope const consequents = node.cases.flatMap(c => c.consequent); this.checkRedeclarations(consequents); return this.withScope(this.declaredNames(consequents), () => this.withJumpTarget('switches', () => this.generateSwitchStatement(node))); } case 'BreakStatement': if (node.label) { return this.generateLabeledJump(node, 'break'); } if (this.jumpTargets.loops + this.jumpTargets.switches === 0) { this.errors.push(`Illegal break statement at line ${node.line}, column ${node.column}: 'шикастан' must be inside a loop or 'интихоб'`); } return this.indent('break;'); case 'ContinueStatement': if (node.label) { return this.generateLabeledJump(node, 'continue'); } if (this.jumpTargets.loops === 0) { this.errors.push(`Illegal continue statement at line ${node.line}, column ${node.column}: 'давом' must be inside a loop`); } return this.indent('continue;'); default: { const unknown = node; this.errors.push(`Unknown statement type: ${unknown.type ?? 'unknown'}`); return ''; } } } /** * ES modules allow `интизор` (and `барои интизор`) at their top level, * outside functions; CommonJS output only with the `topLevelAwait` option. */ allowsTopLevelAwait() { return this.functionDepth === 0 && (this.module === 'esm' || this.topLevelAwait); } generateVariableDeclaration(node) { const kind = this.declarationKeyword(node); return this.indent(`${kind} ${this.generateDeclarator(node)};`); } /** `тағ а = 1, б = 2;` → `let а = 1, б = 2;` */ generateVariableDeclarationList(node) { const kind = this.declarationKeyword(node); const declarators = node.declarations.map(declaration => this.generateDeclarator(declaration)); return this.indent(`${kind} ${declarators.join(', ')};`); } /** * `let`, `const`, or `using` / `await using` for `истифода` / `интизор истифода` * (lowered by TypeScript, since Node.js does not run them yet). */ declarationKeyword(node) { if (node.using) { this.lowering.usingDeclarations = true; // Allowed in a `ҳамзамон` function and at the top level of an ES module if (node.using === 'async' && !this.inAsyncFunction && !this.allowsTopLevelAwait()) { this.errors.push(`'интизор истифода' is only allowed inside a 'ҳамзамон' function at line ${node.line}, column ${node.column}`); } return node.using === 'async' ? 'await using' : 'using'; } return node.kind === 'СОБИТ' ? 'const' : 'let'; } /** The binding and initializer of one declaration: `а = 1`, `[б, в] = р`. */ generateDeclarator(node) { const pattern = this.generatePattern(node.identifier); const type = `${node.definite ? this.definiteMark() : ''}${this.typeAnnotationText(node.typeAnnotation)}`; const init = node.init ? ` = ${this.generateExpression(node.init, exports.PREC.ASSIGNMENT)}` : ''; return `${pattern}${type}${init}`; } // --------------------------------------------------------------------------- // Type hooks: types are erased from JavaScript; the TypeScript emitter // (src/ts-emitter.ts) overrides these to keep them. // --------------------------------------------------------------------------- /** `: Т` after a binding, parameter or property; '' in JavaScript. */ typeAnnotationText(_annotation) { return ''; } /** `: Т` after a parameter list; '' in JavaScript. */ returnTypeText(_annotation) { return ''; } /** `<Т мерос У = В>` after a function, class or method name; '' in JavaScript. */ typeParametersText(_params) { return ''; } /** `<рақам>` after a callee, constructor or superclass; '' in JavaScript. */ typeArgumentsText(_args) { return ''; } /** The definite assignment assertion `!` of `тағ х!: рақам`; '' in JavaScript. */ definiteMark() { return ''; } /** The `?` of an optional parameter or property; '' in JavaScript. */ optionalMark(_optional) { return ''; } /** `хосусӣ танҳохонӣ ` of a constructor parameter property; '' in JavaScript. */ parameterModifiers(_param) { return ''; } /** `мавҳум ` before `class`; '' in JavaScript. */ classModifiers(_node) { return ''; } /** ` implements И<Т>, Ҷ` after the heritage; '' in JavaScript. */ implementsClause(_node) { return ''; } /** Modifiers before a class member's name: `static ` in JavaScript. */ memberModifiers(member) { return member.static ? 'static ' : ''; } /** Members a class gets besides its own, at the start of its body: none in JavaScript. */ extraClassMembers(_node) { return []; } /** * A method without a body: abstract, an overload signature or a member of * an `эълон синф`. Nothing in JavaScript. */ generateMethodSignature(_node) { return ''; } /** A field that only declares a type: an index signature, `эълон` or `мавҳум`. */ generateFieldSignature(_node) { return ''; } /** The `this` parameter of a function, `this: Т` (`ин: Т`); '' in JavaScript. */ thisParameterText(_thisType) { return ''; } /** * Hook for position tracking: `code` generated for `node`. The TypeScript * emitter prefixes a position marker; JavaScript keeps statement markers only. */ markPosition(_node, code) { return code; } /** * A type assertion (`х чун Т`, `<Т>х`, `х бармесоё Т`, `х!`). Types are * erased, so JavaScript emits the expression it wraps. */ generateAssertion(node, minPrec) { return this.generateExpression(node.expression, minPrec); } /** Position marker text for `node` (see `generateWithMappings`). */ positionMarker(node) { return `${POSITION_MARKER}${node.line},${Math.max(node.column - 1, 0)}${POSITION_MARKER}`; } generateFunctionDeclaration(node) { const async = node.async ? 'async ' : ''; const star = node.generator ? '*' : ''; const name = this.generateIdentifier(node.name, true); const typeParameters = this.typeParametersText(node.typeParameters); const { params, body } = this.withNewTarget(() => this.generateFunctionParts(node.params, node.body, node.async, node.thisType, { name: node.name.name, generator: node.generator, })); const returnType = this.returnTypeText(node.returnType); return this.indent(`${async}function${star} ${name}${typeParameters}(${params})${returnType} ${body}`); } /** * Parameter list shared by every function form: `а = 1`, `...а` and * destructuring patterns. */ generateParams(params) { return params .map(param => { const target = param.pattern ? this.generatePattern(param.pattern) : this.generateIdentifier(param.name, true); const type = `${this.optionalMark(param.optional)}${this.typeAnnotationText(param.typeAnnotation)}`; const defaultValue = param.defaultValue ? ` = ${this.generateExpression(param.defaultValue, exports.PREC.ASSIGNMENT)}` : ''; // `@ворид() х` (experimentalDecorators): lowered by TypeScript if (param.decorators?.length) this.checkParameterDecorators(param); const decorators = this.generateDecorators(param.decorators); const modifiers = this.parameterModifiers(param); return `${decorators}${modifiers}${param.rest ? '...' : ''}${target}${type}${defaultValue}`; }) .join(', '); } /** * Parameter list and body of a function, with the parameters in scope; a * `this` parameter (`thisType`) comes first. */ generateFunctionParts(params, body, isAsync = false, thisType, _function = {}) { const paramNames = this.paramNames(params); return this.withScope(paramNames, () => ({ params: this.withThisParameter(thisType, this.generateParams(params)), body: this.withFunctionBoundary(() => this.generateBlockStatement(body, [], paramNames), Boolean(isAsync)), })); } /** `this: Т, а, б`: the parameters after the `this` parameter, if any. */ withThisParameter(thisType, params) { const thisParameter = this.thisParameterText(thisType); if (!thisParameter) return params; return params ? `${thisParameter}, ${params}` : thisParameter; } /** * A block as it follows a header on the same line (`if (…) `, `try `, a * function signature): it starts with `{` itself, its statements one level * deeper than the current indentation and the closing `}` at it. * * `scopeNames` are bound in the block's scope (a catch parameter); a function * body passes its `paramNames` instead, which it may redeclare as functions. */ generateBlockStatement(node, scopeNames = [], paramNames) { if (node.body.length === 0) { return '{}'; } if (paramNames) { this.checkRedeclarations(node.body, paramNames, true); } else { this.checkRedeclarations(node.body, scopeNames); } this.indentLevel++; const statements = this.withScope([...scopeNames, ...this.declaredNames(node.body)], () => this.generateStatements(node.body)); this.indentLevel--; // A block of empty statements (`{ ; }`) is empty if (statements.length === 0) return '{}'; return `{\n${statements.join('\n')}\n${this.getIndent()}}`; } generateReturnStatement(node) { if (this.inStaticBlock) { this.errors.push(`Illegal return statement at line ${node.line}, column ${node.column}: 'бозгашт' cannot be used in a static block`); } const argument = node.argument ? ` ${this.generateExpression(node.argument)}` : ''; return this.indent(`return${argument};`); } /** * The body of an `if` branch or a loop, emitted after its header: a block * as is, a single statement braced and indented one level deeper. */ generateBody(node) { if (node.type === 'BlockStatement') { return this.generateBlockStatement(node); } this.indentLevel++; const statements = this.generateStatements([node]); this.indentLevel--; return statements.length > 0 ? `{\n${statements.join('\n')}\n${this.getIndent()}}` : '{}'; } generateIfStatement(node) { const test = this.generateTest(node.test, this.generateExpression(node.test)); let result = this.indent(`if (${test}) `) + this.generateBody(node.consequent); if (node.alternate) { result += ' else '; if (node.alternate.type === 'IfStatement') { // `else if` continues this line: drop the nested statement's indentation // (but keep its position marker, which follows the indentation) result += this.generateStatement(node.alternate).slice(this.getIndent().length); } else { result += this.generateBody(node.alternate); } } return result; } generateWhileStatement(node) { const test = this.generateTest(node.test, this.generateExpression(node.test)); return this.indent(`while (${test}) `) + this.generateBody(node.body); } generateDoWhileStatement(node) { const body = this.generateBody(node.body); const test = this.generateTest(node.test, this.generateExpression(node.test)); return this.indent('do ') + `${body} while (${test});`; } /** * `берун: барои (…) { … }`. As in JavaScript, a label may not repeat one * that encloses it, and only labels of loops can be continued. */ generateLabeledStatement(node) { const name = node.label.name; if (this.labels.some(label => label.name === name)) { this.errors.push(`Label '${name}' has already been declared at line ${node.line}, column ${node.column}`); } if (JS_RESERVED_WORDS.has(name)) { this.errors.push(`'${name}' is a reserved word in JavaScript and cannot be used as a label at line ${node.line}, column ${node.column}`); } let target = node.body; while (target?.type === 'LabeledStatement') target = target.body; this.labels.push({ name, isLoop: LOOP_TYPES.has(target?.type) }); try { // The body continues the label's line: drop its indentation (but keep // its position marker, which follows the indentation) const body = this.generateStatement(node.body).slice(this.getIndent().length); return this.indent(`${name}: ${body || ';'}`); } finally { this.labels.pop(); } } /** `шикастан берун;` / `давом берун;` */ generateLabeledJump(node, keyword) { const name = node.label.name; const label = this.labels.find(candidate => candidate.name === name); if (!label) { this.errors.push(`Undefined label '${name}' at line ${node.line}, column ${node.column}`); } else if (keyword === 'continue' && !label.isLoop) { this.errors.push(`Illegal continue statement at line ${node.line}, column ${node.column}: '${name}' does not label a loop`); } return this.indent(`${keyword} ${name};`); } generateForStatement(node) { const init = node.init ? this.generateStatement(node.init).trim().replace(/;$/, '') : ''; const test = node.test ? this.generateTest(node.test, this.generateExpression(node.test)) : ''; const update = node.update ? this.generateExpression(node.update) : ''; return this.indent(`for (${init}; ${test}; ${update}) `) + this.generateBody(node.body); } /** The left side of a for-in/of head: a declaration, or a target `х`, `о.а`, `[а, б]`. */ generateForInOfLeft(left) { if (left.type === 'VariableDeclaration') { return this.generateStatement(left).trim().replace(/;$/, ''); } return this.generateExpression(left, exports.PREC.CALL); } generateForInStatement(node) { const left = this.generateForInOfLeft(node.left); const right = this.generateExpression(node.right); return this.indent(`for (${left} in ${right}) `) + this.generateBody(node.body); } generateForOfStatement(node) { const left = this.generateForInOfLeft(node.left); const right = this.generateExpression(node.right, exports.PREC.ASSIGNMENT); const head = node.await ? 'for await' : 'for'; return this.indent(`${head} (${left} of ${right}) `) + this.generateBody(node.body); } generateExpressionStatement(node) { let expr = this.generateExpression(node.expression); // A statement starting with these tokens would parse as a block or a declaration if (/^(?:\{|function\b|async\s+function\b|class\b|let\s*\[)/.test(stripPositionMarkers(expr))) { expr = `(${expr})`; } return this.indent(`${expr};`); } /** * Generate an expression, wrapping it in parentheses when it binds more * loosely than its context requires. `minPrec` is the lowest precedence * (see `getPrecedence`) the context accepts without parentheses. */ generateExpression(expression, minPrec = 0) { // Type assertions are erased in JavaScript; what they wrap is // parenthesized by its own precedence if (ASSERTION_TYPES.has(expression.type)) { return this.generateAssertion(expression, minPrec); } const code = this.generateExpressionNode(expression); const wrapped = this.getPrecedence(expression) < minPrec ? `(${code})` : code; return this.markPosition(expression, wrapped); } /** * JavaScript precedence of an expression node: 1 sequence, 2 assignment and * arrow, 3 conditional, 4-15 binary operators (`operatorPrecedence`), 16 * prefix unary/await, 17 postfix update, 19 call/member/new, 20 primary. * Number literals are never negative: `-1` is a unary expression. */ getPrecedence(node) { switch (node.type) { case 'BinaryExpression': return this.binaryPrecedence(node.operator); case 'UpdateExpression': return node.prefix ? exports.PREC.UNARY : exports.PREC.POSTFIX; default: return NODE_PRECEDENCE[node.type] ?? exports.PREC.PRIMARY; } } /** The precedence of a binary operator; the parser makes no other binary expressions. */ binaryPrecedence(operator) { return this.operatorPrecedence.get(operator); } generateExpressionNode(node) { const generate = this.expressionGenerators.get(node.type); if (generate) return generate(node); // The parser makes no other expressions; a syntax tree made elsewhere may this.errors.push(`Unknown expression type: ${node.type}`); return ''; } generateNewTarget(node) { if (node.meta?.name === 'import') { // `ворид.meta` exists only in ES modules if (this.module !== 'esm') { this.errors.push(`'ворид.meta' (import.meta) is only allowed in ES modules at line ${node.line}, column ${node.column}: compile with module 'esm'`); } return 'import.meta'; } if (this.newTargetScopes === 0) { this.errors.push(`new.target expression is not allowed here at line ${node.line}, column ${node.column}: 'нав.target' must be inside a function or class`); } return 'new.target'; } /** `#ном`: it must be declared by an enclosing class, an early error in JavaScript. */ generatePrivateIdentifier(node) { if (!this.privateNames.some(names => names.has(node.name))) { this.errors.push(`Private field '#${node.name}' must be declared in an enclosing class at line ${node.line}, column ${node.column}`); } return `#${node.name}`; } /** Run `generate` inside a function or class body, where `нав.target` is allowed. */ withNewTarget(generate) { this.newTargetScopes++; try { return generate(); } finally { this.newTargetScopes--; } } /** `функсия (…) { … }`; its own name, if any, is in scope in its body only. */ generateFunctionExpression(node) { return this.withScope(node.name ? [node.name.name] : [], () => { const async = node.async ? 'async ' : ''; const name = node.name ? ` ${this.generateIdentifier(node.name, true)}` : ''; // `function* (…)`, `function* ном(…)` const head = node.generator ? `function*${name || ' '}` : `function${name}`; const typeParameters = this.typeParametersText(node.typeParameters); const { params, body } = this.withNewTarget(() => this.generateFunctionParts(node.params, node.body, node.async, node.thisType, { name: node.name?.name, generator: node.generator, })); const returnType = this.returnTypeText(node.returnType); return `${async}${head}${typeParameters}(${params})${returnType} ${body}`; }); } generateYieldExpression(node) { const keyword = node.delegate ? 'yield*' : 'yield'; if (!node.argument) return keyword; return `${keyword} ${this.generateExpression(node.argument, exports.PREC.ASSIGNMENT)}`; } generateArrowFunctionExpression(node) { const async = node.isAsync ? 'async ' : ''; const typeParameters = this.typeParametersText(node.typeParameters); const returnType = this.returnTypeText(node.returnType); if (node.body.type === 'BlockStatement') { // Block body const { params, body } = this.generateFunctionParts(node.params, node.body, node.isAsync); return `${async}${typeParameters}(${params})${returnType} => ${body}`; } return this.withScope(this.paramNames(node.params), () => { const params = this.generateParams(node.params); // Expression body; a leading `{` would be parsed as a block this.functionDepth++; let body; try { body = this.generateExpression(node.body, exports.PREC.ASSIGNMENT); } finally { this.functionDepth--; } if (stripPositionMarkers(body).startsWith('{')) { body = `(${body})`; } return `${async}${typeParameters}(${params})${returnType} => ${body}`; }); } generateImportExpression(node) { // Dynamic import: ворид(specifier) -> import(specifier) // Handle .som extension conversion for dynamic imports (string specifiers only) const source = this.convertSourcePath(this.generateExpression(node.source, exports.PREC.ASSIGNMENT)); if (node.phase !== 'defer') return `import(${source})`; // `ворид.мавқуф(…)`: a promise of the module's deferred namespace if (this.module === 'esm') return `import.defer(${source})`; this.usesDeferHelper = true; const load = (specifier) => `Promise.resolve().then(() => __somonDefer(() => require(${specifier})))`; // The specifier is computed once, when the call runs return node.source.type === 'Literal' ? load(source) : `((__somon_specifier) => ${load('__somon_specifier')})(${source})`; } generateImportDeclaration(node) { // Module resolution: convert .som extensions to .js const source = this.convertSourcePath(this.generateLiteral(node.source)); if (this.module === 'esm') { return this.generateEsmImport(node, this.markPosition(node.source, source)); } // `ворид навъ { … }` and `{ навъ Т }` import types only: no `require` for them if (node.importKind === 'type') return ''; const specifiers = node.specifiers.filter(spec => spec.importKind !== 'type'); if (specifiers.length === 0 && node.specifiers.length > 0) return ''; // `ворид "./м";` only runs the module if (specifiers.length === 0) { return this.indent(`require(${source});`); } // `ворид мавқуф * чун Н аз "./м";`: `Н` requires the module when a member is first read if (node.phase === 'defer') { this.usesDeferHelper = true; return specifiers .map(spec => { const local = this.generateIdentifier(spec.local, true); return this.indent(`const ${local} = __somonDefer(() => require(${source}));`); }) .join('\n'); } const results = []; const tmpVar = `__somon_import_${this.importCounter++}`; results.push(this.indent(`const ${tmpVar} = require(${source});`)); // Handle default imports const defaultImports = specifiers.filter(s => s.type === 'ImportDefaultSpecifier'); if (defaultImports.length > 0) { const localName = this.generateIdentifier(defaultImports[0].local, true); results.push(this.indent(`const ${localName} = ${tmpVar}.default ?? ${tmpVar};`)); } const namespaceImport = specifiers.find(s => s.type === 'ImportNamespaceSpecifier'); if (namespaceImport) { results.push(this.indent(`const ${this.generateIdentifier(namespaceImport.local, true)} = ${tmpVar};`)); } // Handle named imports const namedImports = specifiers.filter(s => s.type === 'ImportSpecifier'); if (namedImports.length > 0) { const destructuring = namedImports .map(spec => { const imported = this.specifierName(spec.imported); const local = this.generateIdentifier(spec.local, true); return imported === local ? imported : `${imported}: ${local}`; }) .join(', '); results.push(this.indent(`const { ${destructuring} } = ${tmpVar};`)); } return results.join('\n'); } /** * `ворид х = require("./м");` → `const х = require("./м.js");`, in an ES * module `import х from "./м.js";` (a CommonJS module's `module.exports` is * its default export); `ворид х = Н.а;` → `const х = Н.а;`. */ generateImportEquals(node) { if (node.importKind === 'type') return ''; const name = this.generateIdentifier(node.id, true); if (!node.source) { return this.indent(`const ${name} = ${this.generateExpression(node.reference, exports.PREC.ASSIGNMENT)};`); } const source = this.convertSourcePath(this.generateLiteral(node.source)); if (this.module === 'esm') { return this.indent(`import ${name} from ${this.markPosition(node.source, source)};`); } return this.indent(`const ${name} = require(${source});`); } /** `содир = х;` → `module.exports = х;`, in an ES module `export default х;`. */ generateExportAssignment(node) { const value = this.generateExpression(node.expression, exports.PREC.ASSIGNMENT); return this.indent(this.module === 'esm' ? `export default ${value};` : `module.exports = ${value};`); } /** * `import а, { б as в } from "./м.js";`, `import * as Н from …`. JavaScript * leaves out type-only imports (`ворид навъ`, `{ навъ Т }`) and bindings used * only as types (see `valueNames`); the module of the latter still runs, as * an `import "./м.js";`. TypeScript keeps them, as `import type`. */ generateEsmImport(node, source) { const keepsTypes = !this.elidesTypes(); if (node.importKind === 'type' && !keepsTypes) return ''; const values = node.specifiers.filter(spec => spec.importKind !== 'type'); if (!keepsTypes && values.length === 0 && node.specifiers.length > 0) return ''; const specifiers = keepsTypes ? node.specifiers : values.filter(spec => !this.valueNames || this.valueNames.has(spec.local.name)); const clauses = []; const named = []; for (const spec of specifiers) { const local = this.generateIdentifier(spec.local, true); if (spec.type === 'ImportDefaultSpecifier') { clauses.unshift(local); } else if (spec.type === 'ImportNamespaceSpecifier') { clauses.push(`* as ${local}`); } else { named.push(this.esmNamedImport(spec, local)); } } if (named.length > 0) clauses.push(`{ ${named.join(', ')} }`); // A deferred module whose namespace is never read never runs: nothing to import if (clauses.length === 0) return node.phase === 'defer' ? '' : this.indent(`import ${source};`); const typeOnly = node.importKind === 'type' ? 'type ' : ''; const phase = node.phase === 'defer' ? 'defer ' : ''; return this.indent(`import ${typeOnly}${phase}${clauses.join(', ')} from ${source};`); } /** `б as в`, `"а-б" as в` or `type Т` in `import { … }`. */ esmNamedImport(spec, local) { const imported = this.specifierName(spec.imported); const typeOnly = spec.importKind === 'type' ? 'type ' : ''; return `${typeOnly}${imported === stripPositionMarkers(local) ? local : `${imported} as ${local}`}`; } /** * The name a module exports, in JavaScript: a member name is written as its * JavaScript name (`содир функсия илова` exports `push`); a name written as * a string (`содир { х чун "а-б" }`, TypeScript 5.6) is that string. */ static exportName(id) { return id.isString ? id.name : (0, builtin_names_1.translateMemberName)(id.name); } /** An export name in `{ … }` of an import or export: a string when written as one (ES2022). */ specifierName(id) { const name = CodeGenerator.exportName(id); return id.isString ? this.stringLiteral(name) : name; } /** `module.exports.ном`, or `module.exports["а-б"]` for a name that is no identifier. */ memberAccess(object, name) { return IDENTIFIER_NAME.test(name) ? `${object}.${name}` : `${object}[${this.stringLiteral(name)}]`; } stringLiteral(text) { return this.generateLiteral({ type: 'Literal', value: text, raw: '', line: 0, column: 0 }); } generateExportDeclaration(node) { if (this.module === 'esm') { return this.generateEsmExport(node); } // `содир навъ { Т };`, `содир навъ * аз …`: types only if (node.exportKind === 'type') return ''; if (node.declaration) { return this.generateExportWithDeclaration(node); } const specifiers = node.specifiers?.filter(spec => spec.exportKind !== 'type'); if (node.specifiers && node.specifiers.length > 0) { if (specifiers.length === 0) return ''; return this.generateExportWithSpecifiers({ ...node, specifiers }); } if (node.source) { return this.generateWildcardExport(node); } return ''; } generateExportWithDeclaration(node) { const declaration = node.declaration; // `содир пешфарз ;` if (node.default && declaration.type === 'ExpressionStatement') { const value = this.generateExpression(declaration.expression, exports.PREC.ASSIGNMENT); return this.indent(`module.exports.default = ${value};`); } const code = this.generateStatement(declaration); const exportNames = this.extractExportNames(declaration); // Type-only declarations don't generate runtime exports if (exportNames.length === 0) { return code; } const commonjsExports = node.default ? [`module.exports.default = ${exportNames[0]};`] : exportNames.map(name => `module.exports.${(0, builtin_names_1.translateMemberName)(name)} = ${name};`); return [withoutTrailingNewlines(code), ...commonjsExports.map(line => this.indent(line))].join('\n'); } extractExportNames(declaration) { // Interfaces, type aliases and `эълон …` declarations don't generate runtime code if (declaration.type === 'InterfaceDeclaration' || declaration.type === 'TypeAlias' || declaration.declare) { return []; } const names = []; this.collectDeclaredNames(declaration, names); return names; } generateExportWithSpecifiers(node) { if (node.source) { return this.generateReExportWithSpecifiers(node); } return this.generateDirectExportSpecifiers(node); } generateReExportWithSpecifiers(node) { const source = this.convertSourcePath(this.generateLiteral(node.source)); const tmpVar = `__somon_reexport_${this.importCounter++}`; const results = []; results.push(this.indent(`const ${tmpVar} = require(${source});`)); for (const spec of node.specifiers) { const exported = this.memberAccess('module.exports', CodeGenerator.exportName(spec.exported)); const local = this.memberAccess(tmpVar, CodeGenerator.exportName(spec.local)); results.push(this.indent(`${exported} = ${local};`)); } return results.join('\n'); } generateDirectExportSpecifiers(node) { return node .specifiers.map(spec => { const exported = this.memberAccess('module.exports', CodeGenerator.exportName(spec.exported)); const local = this.generateIdentifier(spec.local); return this.indent(`${exported} = ${local};`); }) .join('\n'); } generateWildcardExport(node) { const source = this.convertSourcePath(this.generateLiteral(node.source)); const tmpVar = `__somon_reexport_${this.importCounter++}`; const results = []; results.push(this.indent(`const ${tmpVar} = require(${source});`)); // `содир * чун Н аз "./м";` exports the whole module as one member if (node.namespaceExport) { const name = CodeGenerator.exportName(node.namespaceExport); results.push(this.indent(`${this.memberAccess('module.exports', name)} = ${tmpVar};`)); return results.join('\n'); } results.push(this.indent(`Object.keys(${tmpVar}).forEach(key => {`)); this.indentLevel++; results.push(this.indent(`if (key !== 'default') module.exports[key] = ${tmpVar}[key];`)); this.indentLevel--; results.push(this.indent(`});`)); return results.join('\n'); } /** * ES module exports: `export function ф() {}`, `export { а as push };`, * `export default …`, `export { а } from "./м.js";`, `export * as Н from …`. * Export names go through the member-name mapping, as in CommonJS output. */ generateEsmExport(node) { const keepsTypes = !this.elidesTypes(); // `содир навъ { Т };`, `содир навъ * аз …`: types only, `export type` in TypeScript if (node.exportKind === 'type' && !keepsTypes) return ''; const typeOnly = node.exportKind === 'type' ? 'type ' : ''; if (node.declaration) { return this.generateEsmExportDeclaration(node); } if (node.source) { const source = this.markPosition(node.source, this.convertSourcePath(this.generateLiteral(node.source))); if (node.specifiers && node.specifiers.length > 0) { const values = node.specifiers.filter(spec => keepsTypes || spec.exportKind !== 'type'); if (values.length === 0) return ''; const names = values.map(spec => { const local = this.specifierName(spec.local); const exported = this.specifierName(spec.exported); const typeName = spec.exportKind === 'type' ? 'type ' : ''; return `${typeName}${local === exported ? local : `${local} as ${exported}`}`; }); return this.indent(`export ${typeOnly}{ ${names.join(', ')} } from ${source};`); } const namespace = node.namespaceExport ? ` as ${this.specifierName(node.namespaceExport)}` : ''; return this.indent(`export ${typeOnly}*${namespace} from ${source};`); } // Interfaces, type aliases and type-only imports have no runtime binding to export const specifiers = node.specifiers.filter(spec => keepsTypes || (spec.exportKind !== 'type' && !this.typeOnlyNames?.has(spec.local.name))); if (specifiers.length === 0) return ''; const names = specifiers.map(spec => { if (spec.exported.name === spec.local.name) this.esmExportedNames.add(spec.local.name); const local = this.generateIdentifier(spec.local); const exported = this.specifierName(spec.exported); const typeName = spec.exportKind === 'type' ? 'type ' : ''; return `${typeName}${exported === stripPositionMarkers(local) ? local : `${local} as ${exported}`}`; }); return this.indent(`export ${typeOnly}{ ${names.join(', ')} };`); } generateEsmExportDeclaration(node) { const declaration = node.declaration; if (node.default && declaration.type === 'ExpressionStatement') { const value = this.generateExpression(declaration.expression, exports.PREC.ASSIGNMENT); return this.indent(`export default ${value};`); } const code = this.generateStatement(declaration); const names = this.extractExportNames(declaration); if (names.length === 0) { return this.exportTypeDeclaration(code, declaration, Boolean(node.default)); } if (!node.default && CodeGenerator.extendsEarlierDeclaration(code)) { return this.exportExistingBindings(code, names); } names.forEach(name => this.esmExportedNames.add(name)); if (node.default) { if (declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') { return CodeGenerator.prefixDeclaration(code, 'export default '); } return [ withoutTrailingNewlines(code), this.indent(`export { ${names[0]} as default };`), ].join('\n'); } // A name that is a built-in member name is exported under its JavaScript name if (names.every(name => (0, builtin_names_1.translateMemberName)(name) === name)) { return CodeGenerator.prefixDeclaration(code, 'export '); } const list = names.map(name => { const exported = (0, builtin_names_1.translateMemberName)(name); return exported === name ? name : `${name} as ${exported}`; }); return [withoutTrailingNewlines(code), this.indent(`export { ${list.join(', ')} };`)].join('\n'); } /** * Whether a generated declaration only extends a binding an earlier one * created: a later block of a merged `номфазо`/`шумориш` (also merged into * a class or function) is just its `(function (Н) { … })(Н || (Н = {}));`. */ static extendsEarlierDeclaration(code) { return /^ *(?:\0[^\0]*\0)?\(/.test(code); } /** * `содир` on a declaration that extends an earlier binding: `export` cannot * prefix the expression, so the binding is exported by name, once. */ exportExistingBindings(code, names) { const pending = names.filter(name => !this.esmExportedNames.has(name)); if (pending.length === 0) return code; pending.forEach(name => this.esmExportedNames.add(name)); const list = pending.map(name => { const exported = (0, builtin_names_1.translateMemberName)(name); return exported === name ? name : `${name} as ${exported}`; }); return [withoutTrailingNewlines(code), this.indent(`export { ${list.join(', ')} };`)].join('\n'); } /** * An exported declaration that only declares types (`интерфейс`, `навъ`): * nothing to export in JavaScript, where it is a comment. */ exportTypeDeclaration(code, _declaration, _isDefault) { return code; } /** Inserts `prefix` (`export `) before a generated statement, after its indentation and marker. */ static prefixDeclaration(code, prefix) { return code.replace(/^( *(?:\0[^\0]*\0)?)/, start => `${start}${prefix}`); } /** * Rewrite a quoted module specifier for the emitted CommonJS: a trailing * `.som` becomes `.js`, and a relative specifier without a JavaScript/JSON * extension gets `.js` appended. Anything else is returned unchanged. */ convertSourcePath(source) { const match = /^(["'])(.*)\1$/s.exec(source); if (!match) { return source; } const [, quote, specifier] = match; if (specifier.endsWith('.som')) { return `${quote}${specifier.slice(0, -'.som'.length)}.js${quote}`; } if (/^\.\.?\//.test(specifier) && !/\.(?:[cm]?js|json)$/.test(specifier)) { // A relative import without an extension: `./м` → `./м.js`, or `./м/index.js` for a directory // (`./м/` always names a directory) const file = specifier.endsWith('/') || this.isDirectoryImport?.(specifier) ? `${specifier.replace(/\/$/, '')}/index` : specifier; return `${quote}${file}.js${quote}`; } return source; } /** `binding`: the identifier declares a name rather than referencing one. */ generateIdentifier(node, binding = false) { return this.markPosition(node, this.identifierText(node, binding)); } identifierText(node, binding) { // In an enum member initializer, earlier members are read by name: `Б = А + ф()` const enumMember = binding ? undefined : this.enumMembers?.get((0, builtin_names_1.translateMemberName)(node.name)); if (enumMember) { return enumMember; } // In a merged namespace, what its other blocks export: `Н.ном` const namespaceMember = binding ? undefined : this.namespaceMemberReference(node.name); if (namespaceMember) { return namespaceMember; } // Built-in names (`рӯйхат` → `Array`, `чоп` → `console`, …) are mapped only // when the program does not declare a binding of that name in scope; // otherwise `тағ рӯйхат = []` would shadow the global `Array`. const declared = this.isDeclared(node.name); if (!declared && !binding && INPUT_FUNCTIONS.has(node.name)) this.usesInput = true; const mapped = declared ? undefined : this.mapBuiltinIdentifier(node.name); if (mapped) { return mapped; } // `null`, `true`, `this`, … are fine as values, but never as declared names if (JS_RESERVED_WORDS.has(node.name) && (binding || !JS_KEYWORD_EXPRESSIONS.has(node.name))) { this.errors.push(`'${node.name}' is a reserved word in JavaScript and cannot be used as an identifier at line ${node.line}, column ${node.column}`); } return node.name; } mapBuiltinIdentifier(name) { // Map built-in literals if (name === 'беқимат') { return 'undefined'; } // Handle Хато (capitalized) as Error constructor if (name === 'Хато') { return 'Error'; } // Map built-in constructors/objects (when used as identifiers) const builtinConstructors = [ 'чоп', 'сатр', 'рӯйхат', 'объект', 'математика', 'Риёзӣ', 'сатрМетодҳо', 'ваъда', 'Ваъда', ]; return builtinConstructors.includes(name) ? builtin_names_1.BUILTIN_MAPPINGS.get(name) : undefined; } isDeclared(name) { return this.scopes.some(scope => scope.has(name)); } /** Run `generate` with `names` declared in a new innermost scope. */ withScope(names, generate) { this.scopes.push(new Set(names)); try { return generate(); } finally { this.scopes.pop(); } } /** Run `generate` inside one more loop or `интихоб`. */ withJumpTarget(kind, generate) { this.jumpTargets[kind]++; try { return generate(); } finally { this.jumpTargets[kind]--; } } /** * Run `generate` for a function body: loops and labels around the function * are not jump targets, and a `бозгашт` returns from the function, not from * an enclosing static block. `isAsync`: the function is `ҳамзамон`. */ withFunctionBoundary(generate, isAsync = false) { const outer = this.jumpTargets; const outerLabels = this.labels; const outerAsync = this.inAsyncFunction; const outerStaticBlock = this.inStaticBlock; this.jumpTargets = { loops: 0, switches: 0 }; this.labels = []; this.inAsyncFunction = isAsync; this.inStaticBlock = false; this.functionDepth++; try { return generate(); } finally { this.jumpTargets = outer; this.labels = outerLabels; this.inAsyncFunction = outerAsync; this.inStaticBlock = outerStaticBlock; this.functionDepth--; } } /** * Report a name declared twice in one scope, an early SyntaxError in * JavaScript (every SomonScript variable is `let`/`const`). `bound` holds * names the scope already binds: parameters (`functionBody`), which a * function declaration may reuse, or a catch parameter, which nothing may. * Two function declarations of one name are rejected as well: sloppy-mode * JavaScript would let the second replace the first, but strict code * (ES modules, bundles) rejects it, and it is almost always a mistake. */ /** * A module has one default export: two are JavaScript's early error in ES * modules and TypeScript's TS2528 ("A module cannot have multiple default * exports"). Overload signatures and types (`содир пешфарз интерфейс`) are * not values and do not count. */ checkDefaultExports(body) { let exported = false; for (const stmt of body) { if (!this.exportsDefaultValue(stmt)) continue; if (exported) { this.errors.push(`A module cannot have multiple default exports at line ${stmt.line}, column ${stmt.column}`); } exported = true; } } exportsDefaultValue(stmt) { if (stmt.type !== 'ExportDeclaration') return false; const node = stmt; if (node.exportKind === 'type') return false; if (node.default) { const declaration = node.declaration; return !(declaration && (TYPE_ONLY_DECLARATIONS.has(declaration.type) || declaration.declare === true)); } return (node.specifiers ?? []).some(spec => spec.exportKind !== 'type' && DEFAULT_NAMES.has(spec.exported.name)); } checkRedeclarations(statements, bound = [], functionBody = false) { const declared = new Map(); const groups = new Map(); for (const stmt of statements) { const names = []; this.collectDeclaredNames(stmt, names); if (names.length === 0) continue; // Names come from a declaration, exported or not const declaration = stmt.type === 'ExportDeclaration' ? stmt.declaration : stmt; const reusesParam = functionBody && declaration.type === 'FunctionDeclaration'; for (const name of names) { const earlier = declared.get(name); if (earlier && CodeGenerator.mergesWith(earlier, declaration)) { this.addToMergeGroup(groups, name, earlier, declaration); continue; } if (earlier || (bound.includes(name) && !reusesParam)) { this.errors.push(`Identifier '${name}' has already been declared at line ${stmt.line}, column ${stmt.column}`); } declared.set(name, declaration); } } } /** * TypeScript's declaration merging: a namespace merges with an earlier * namespace, class, function or enum of its name, and an enum with an * earlier enum or namespace. */ static mergesWith(earlier, later) { if (later.type === 'NamespaceDeclaration') { return [ 'NamespaceDeclaration', 'ClassDeclaration', 'FunctionDeclaration', 'EnumDeclaration', ].includes(earlier.type); } return (later.type === 'EnumDeclaration' && (earlier.type === 'EnumDeclaration' || earlier.type === 'NamespaceDeclaration')); } addToMergeGroup(groups, name, earlier, later) { let group = groups.get(name); if (!group) { group = { name, declarations: [earlier], enumValues: new Map(), enumMembers: new Map(), }; groups.set(name, group); this.mergeGroups.set(earlier, group); } group.declarations.push(later); this.mergeGroups.set(later, group); } /** Names bound by the statements of one block (lexical declarations are hoisted to it). */ declaredNames(statements) { const names = []; for (const stmt of statements) { this.collectDeclaredNames(stmt, names); } return names; } collectDeclaredNames(stmt, names) { switch (stmt?.type) { case 'VariableDeclaration': this.collectPatternNames(stmt.identifier, names); break; case 'VariableDeclarationList': for (const declaration of stmt.declarations) { this.collectPatternNames(declaration.identifier, names); } break; case 'FunctionDeclaration': case 'ClassDeclaration': case 'NamespaceDeclaration': case 'EnumDeclaration': names.push(stmt .name.name); break; case 'ImportDeclaration': names.push(...stmt.specifiers.map(spec => spec.local.name)); break; case 'ImportEqualsDeclaration': names.push(stmt.id.name); break; case 'ExportDeclaration': this.collectDeclaredNames(stmt.declaration, names); break; } } paramNames(params) { const names = []; for (const param of params) { this.collectPatternNames(param.pattern ?? param.name, names); } return names; } collectPatternNames(pattern, names) { switch (pattern?.type) { case 'Identifier': names.push(pattern.name); break; case 'AssignmentPattern': this.collectPatternNames(pattern.left, names); break; case 'SpreadElement': case 'RestElement': this.collectPatternNames(pattern.argument, names); break; case 'ArrayPattern': pattern.elements.forEach(element => this.collectPatternNames(element, names)); break; case 'ObjectPattern': for (const prop of pattern.properties) { this.collectPatternNames(prop.type === 'PropertyPattern' ? (prop.value ?? prop.key) : prop, names); } break; } } generateLiteral(node) { if (typeof node.value === 'string') { // Properly escape string literals const escaped = node.value .replaceAll('\\', '\\\\') // Escape backslashes first .replaceAll('"', '\\"') // Escape quotes .replaceAll('\n', '\\n') // Escape newlines .replaceAll('\t', '\\t') // Escape tabs .replaceAll('\r', '\\r') // Escape carriage returns .replaceAll('\0', '\\x00'); // Keep NUL out of the output return `"${escaped}"`; } if (node.value === null) { return 'null'; } if (typeof node.value === 'number' && CodeGenerator.isNumericLiteralText(node.raw)) { // Keep the literal as written: `0xFF`, `1e3`, `.5`, `10n` return node.raw; } return String(node.value); } static isNumericLiteralText(raw) { return (typeof raw === 'string' && /^(?:0[xX][0-9a-fA-F]+n?|0[oO][0-7]+n?|0[bB][01]+n?|\d+n|(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?)$/.test(raw)); } generateTemplateLiteral(node) { let result = '`'; for (let i = 0; i < node.quasis.length; i++) { const quasi = node.quasis[i]; // Emit the decoded text, re-escaping whatever would end or reinterpret // the template: `\`, a backtick, `${`, and CR (which JS normalises to LF). // Only a tagged template may have text that is not cooked (an invalid escape). const text = quasi.value.cooked; result += text .replace(/\\|`|\$\{/g, match => `\\${match}`) .replaceAll('\r', '\\r') .replaceAll('\0', '\\x00'); // Add the expression part if it exists if (i < node.expressions.length) { result += '${'; result += this.generateExpression(node.expressions[i]); result += '}'; } } result += '`'; return result; } /** * `тег\`…\``: the tag receives the text as written (`String.raw`), so the * quasis are emitted raw rather than re-escaped from their cooked value. */ generateTaggedTemplate(node) { const tag = this.generateExpression(node.tag, exports.PREC.CALL) + this.typeArgumentsText(node.typeArguments); const { quasis, expressions } = node.quasi; let template = ''; quasis.forEach((quasi, i) => { // Line terminators are LF in raw text too; NUL is the position marker template += quasi.value.raw.replace(/\r\n?/g, '\n').replaceAll('\0', '\\x00'); if (i < expressions.length) { template += `\${${this.generateExpression(expressions[i])}}`; } }); return `${tag}\`${template}\``; } generateBinaryExpression(node) { const precedence = this.binaryPrecedence(node.operator); // `**` is right-associative, and `-а ** б` is a SyntaxError, so its left // operand must bind tighter than a unary expression. Every other binary // operator is left-associative: an equal-precedence right operand needs // parentheses (`а - (б - в)`). const isExponent = node.operator === '**'; let left = this.generateExpression(node.left, isExponent ? exports.PREC.UNARY + 1 : precedence); const right = this.generateExpression(node.right, isExponent ? precedence : precedence + 1); // `(а < б) > (в)`: without the parentheses TypeScript reads a call `а<б>(в)` if (node.operator === '>' && this.isTypeArgumentLike(node.left)) left = `(${left})`; return `${this.wrapMixedNullish(node, node.left, left)} ${node.operator} ${this.wrapMixedNullish(node, node.right, right)}`; } /** * Whether the output language reads `а < б > (в)` and `ф(а < б, в > (г))` * as calls with type arguments, so that comparisons there need * parentheses: TypeScript does, JavaScript does not. */ readsTypeArguments() { return false; } /** A `<` or `<<` comparison that could open type arguments in the output. */ isTypeArgumentLike(node) { const operator = skipAssertions(node).operator; return (this.readsTypeArguments() && skipAssertions(node).type === 'BinaryExpression' && (operator === '<' || operator === '<<')); } /** `??` cannot be combined with an unparenthesised `&&` or `||` operand. */ wrapMixedNullish(parent, operand, code) { const child = skipAssertions(operand); if (parent.operator !== '??' || child.type !== 'BinaryExpression') { return code; } const operator = child.operator; return operator === '&&' || operator === '||' ? `(${code})` : code; } generateConditionalExpression(node) { const test = this.generateExpression(node.test, exports.PREC.CONDITIONAL + 1); const consequent = this.generateExpression(node.consequent, exports.PREC.ASSIGNMENT); const alternate = this.generateExpression(node.alternate, exports.PREC.ASSIGNMENT); return `${test} ? ${consequent} : ${alternate}`; } generateUnaryExpression(node) { const target = node.argument; if (node.operator === 'delete' && target.property?.type === 'PrivateIdentifier') { this.errors.push(`Private fields can not be deleted at line ${node.line}, column ${node.column}`); } const argument = this.generateExpression(node.argument, exports.PREC.UNARY); // Word operators (`typeof`, `void`, `delete`) need a space, and so does // `- -а` / `+ +а`, which would otherwise read as `--а` / `++а`. const needsSpace = /^[a-z]/.test(node.operator) || ((node.operator === '-' || node.operator === '+') && stripPositionMarkers(argument).startsWith(node.operator)); return `${node.operator}${needsSpace ? ' ' : ''}${argument}`; } generateUpdateExpression(node) { const argument = this.generateExpression(node.argument, exports.PREC.POSTFIX + 1); if (node.prefix) { return `${node.operator}${argument}`; } else { return `${argument}${node.operator}`; } } generateCallExpression(node) { let callee = this.generateExpression(node.callee, exports.PREC.CALL); // `чоп(…)` prints as `чоп.сабт(…)` does; so does the older `нишондиҳӣ(…)` if (this.isPrintCall(node) || stripPositionMarkers(callee) === 'нишондиҳӣ') { callee = this.markPosition(node.callee, 'console.log'); } const args = this.generateArguments(node.arguments); const typeArguments = this.typeArgumentsText(node.typeArguments); return `${callee}${node.optional ? '?.' : ''}${typeArguments}(${args})`; } /** `чоп(…)`, calling the built-in `чоп` (not a binding of that name). */ isPrintCall(node) { return (node.callee.type === 'Identifier' && node.callee.name === 'чоп' && !this.isDeclared('чоп')); } /** Call/new argument list; elements may be `SpreadElement`s. */ generateArguments(args) { return args .map((arg, index) => this.generateListElement(arg, index < args.length - 1)) .join(', '); } /** * An element of an argument list, array or sequence; `beforeAnother` when * more elements follow: `ф((а < б), в > (г))`, not the call `ф(а<б, в>(г))`. */ generateListElement(element, beforeAnother) { if (element.type === 'SpreadElement') { return this.generateSpreadElement(element); } const code = this.generateExpression(element, exports.PREC.ASSIGNMENT); return beforeAnother && this.isTypeArgumentLike(element) ? `(${code})` : code; } /** `х = 1`, `о.а += 2`; a destructuring target is an array or object literal: `[а, б] = [б, а]`. */ generateAssignmentExpression(node) { const left = this.generateExpression(node.left); const right = this.generateExpression(node.right, exports.PREC.ASSIGNMENT); return `${left} ${node.operator} ${right}`; } /** * Try to map object name if it's a built-in object */ mapBuiltinObject(node, object) { const objectNode = skipAssertions(node.object); if (objectNode.type !== 'Identifier') { return { mapped: object, wasMapped: false }; } const objectName = objectNode.name; const builtinObjects = ['чоп', 'математика', 'объект', 'Риёзӣ', 'сатр', 'сатрМетодҳо']; if (!builtinObjects.includes(objectName) || this.isDeclared(objectName)) { return { mapped: object, wasMapped: false }; } return { mapped: builtin_names_1.BUILTIN_MAPPINGS.get(objectName), wasMapped: true }; } /** * Check if object looks like a user class instance */ /** * Try to map property name based on context */ mapPropertyName(node, property, objectMapped) { if (node.computed || node.property.type !== 'Identifier') { return property; } const propertyName = node.property.name; const mappedProperty = builtin_names_1.BUILTIN_MAPPINGS.get(propertyName); if (!mappedProperty) { return property; } // Always map if the property is a recognised Tajik builtin method name. // The previous `looksLikeClassInstance` heuristic (lowercase Cyrillic + // underscore) created asymmetry with MethodDefinition emission: a class // method declared as `илова` emits `push`, but a call on `list_name.илова` // would not — runtime "not a function". Consistency beats the heuristic: // if the user names a class method after a builtin, both sides rewrite. const shouldMap = objectMapped || builtin_names_1.MEMBER_ALIASES.has(propertyName); return shouldMap ? mappedProperty : property; } generateMemberExpression(node) { if (node.object.type === 'Super' && node.property.type === 'PrivateIdentifier') { this.errors.push(`Unexpected private field '#${node.property.name}' after 'супер' at line ${node.property.line}, column ${node.property.column}`); } let object = this.generateExpression(node.object, exports.PREC.CALL); // `5.toFixed()` would read the dot as a decimal point if (skipAssertions(node.object).type === 'Literal' && /^\d+$/.test(stripPositionMarkers(object))) { object = `(${object})`; } // A property name is not a variable reference: emit it verbatim (subject // to the member-name mapping below), never as a mapped/checked identifier. let property = !node.computed && node.property.type === 'Identifier' ? node.property.name : this.generateExpression(node.property); const { mapped: mappedObject, wasMapped: objectMapped } = this.mapBuiltinObject(node, object); object = objectMapped ? this.markPosition(node.object, mappedObject) : mappedObject; property = this.mapPropertyName(node, property, objectMapped); // `чоп.Хато`, spelt like the Error constructor, is `console.error` as `чоп.хато` is if (stripPositionMarkers(object) === 'console' && property === 'Error') { property = 'error'; } if (!node.computed) { property = this.markPosition(node.property, property); } if (node.computed) { return `${object}${node.optional ? '?.' : ''}[${property}]`; } return `${object}${node.optional ? '?.' : '.'}${property}`; } generateArrayExpression(node) { // Holes stay holes: `[1, , 3]`, and `[1, ,]` keeps its trailing one const last = node.elements.length - 1; const elements = node.elements.map((element, index) => element ? this.generateListElement(element, index < last) : ''); const trailingHole = node.elements.length > 0 && !node.elements[node.elements.length - 1]; return `[${elements.join(', ')}${trailingHole ? ',' : ''}]`; } generateObjectExpression(node) { const properties = node.properties .map(prop => { if (prop.type === 'SpreadElement') { return this.generateSpreadElement(prop); } return this.generateProperty(prop); }) .join(', '); return `{${properties}}`; } generateProperty(prop) { const key = prop.computed ? `[${this.generateExpression(prop.key, exports.PREC.ASSIGNMENT)}]` : this.generatePropertyKey(prop.key); if (prop.method && prop.value.type === 'FunctionExpression') { const fn = prop.value; const asyncPrefix = prop.kind ? `${prop.kind} ` : fn.async ? 'async ' : ''; const star = fn.generator ? '*' : ''; const typeParameters = this.typeParametersText(fn.typeParameters); const { params, body } = this.withNewTarget(() => this.generateFunctionParts(fn.params, fn.body, fn.async, fn.thisType, { name: prop.key.type === 'Identifier' ? prop.key.name : undefined, generator: fn.generator, })); const returnType = this.returnTypeText(fn.returnType); return `${asyncPrefix}${star}${key}${typeParameters}(${params})${returnType} ${body}`; } const value = this.generateExpression(prop.value, exports.PREC.ASSIGNMENT); return `${key}: ${value}`; } /** * Non-computed key of an object literal, class member or destructuring * pattern. Identifier keys go through the same Tajik→JS member-name mapping * as `о.ном` accesses (`translateMemberName`), so user objects round-trip. */ generatePropertyKey(key) { if (key.type === 'Identifier') { return this.markPosition(key, (0, builtin_names_1.translateMemberName)(key.name)); } return this.markPosition(key, this.generateLiteral(key)); } generateTryStatement(node) { let result = this.indent('try ') + this.generateBlockStatement(node.block); if (node.handler) { const { param, typeAnnotation } = node.handler; const names = []; this.collectPatternNames(param, names); // A parameterless catch stays parameterless (ES2019) so it cannot shadow // an outer variable such as `error`. if (param) { const binding = this.withScope(names, () => param.type === 'Identifier' ? this.generateIdentifier(param, true) : this.generatePattern(param)); result += ` catch (${binding}${this.typeAnnotationText(typeAnnotation)}) `; } else { result += ' catch '; } result += this.generateBlockStatement(node.handler.body, names); } if (node.finalizer) { result += ' finally '; result += this.generateBlockStatement(node.finalizer); } return result; } generateThrowStatement(node) { const argument = this.generateExpression(node.argument); return this.indent(`throw ${argument};`); } generateAwaitExpression(node) { // A CommonJS module is a function body that is not async if (this.functionDepth === 0 && !this.allowsTopLevelAwait()) { this.errors.push(`Top-level 'интизор' (await) is only allowed in ES modules at line ${node.line}, column ${node.column}: compile with module 'esm' or move it into a 'ҳамзамон' function`); } const argument = this.generateExpression(node.argument, exports.PREC.UNARY); return `await ${argument}`; } generateNewExpression(node) { let callee = this.generateExpression(node.callee, exports.PREC.CALL); // `new f().К()` would call `new f()`; a call anywhere in the callee's // member chain needs parentheses: `new (f().К)()`. An optional chain is // already in them (`ChainExpression`): `нав (о?.К)()`. if (this.chainContainsCall(node.callee)) { callee = `(${callee})`; } const typeArguments = this.typeArgumentsText(node.typeArguments); return `new ${callee}${typeArguments}(${this.generateArguments(node.arguments)})`; } chainContainsCall(node) { let current = skipAssertions(node); while (current.type === 'MemberExpression' || current.type === 'TaggedTemplateExpression') { current = skipAssertions(current.type === 'TaggedTemplateExpression' ? current.tag : current.object); } return current.type === 'CallExpression'; } generateInterfaceDeclaration(node) { // Interfaces are TypeScript-only constructs, so we generate a comment in JavaScript // They should NOT generate any executable code at all const name = node.name.name; return this.indent(`// Interface: ${name}\n`); } generateTypeAlias(node) { // Type aliases are TypeScript-only constructs, so we generate a comment in JavaScript const name = node.name.name; return this.indent(`// Type alias: ${name}\n`); } /** * `шумориш Ранг { Сурх, Сабз = 5, Ном = "н" }` (also `собит шумориш`) as * TypeScript emits an enum: * * var Ранг; * (function (Ранг) { * Ранг[Ранг["Сурх"] = 0] = "Сурх"; * Ранг[Ранг["Сабз"] = 5] = "Сабз"; * Ранг["Ном"] = "н"; * })(Ранг || (Ранг = {})); * * Constant initializers (literals, arithmetic, earlier members) are folded, * string members get no reverse mapping, and a member without initializer * is the previous numeric member plus one. Member names go through the * member-name mapping, like `Ранг.дарозӣ` (→ `Ранг.length`) does. */ generateEnumDeclaration(node) { const name = this.generateIdentifier(node.name, true); // At the top level a `var`, as TypeScript emits it; in a block a `let`, // which stays in the block like every SomonScript declaration const keyword = this.scopes.length <= 1 ? 'var' : 'let'; // Merged enums (`шумориш Э { А } шумориш Э { Б = 1 }`) share their members const group = this.mergeGroups.get(node); const values = group?.enumValues ?? new Map(); const earlier = group?.enumMembers ?? new Map(); let previous = -1; const first = node.members[0]; if (group && first && !first.initializer) { if (group.omittedFirstInitializer) { this.errors.push(`In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element at line ${first.line}, column ${first.column}`); } group.omittedFirstInitializer = true; } this.indentLevel++; const lines = node.members.map(member => { const key = member.id.type === 'Identifier' ? (0, builtin_names_1.translateMemberName)(member.id.name) : String(member.id.value); const keyText = this.enumValueText(key); let value; let code; if (member.initializer) { value = this.enumConstant(member.initializer, node.name.name, values); code = value === undefined ? this.withEnumMembers(earlier, () => this.generateExpression(member.initializer, exports.PREC.ASSIGNMENT)) : this.enumValueText(value); } else if (typeof previous === 'number') { value = previous + 1; code = this.enumValueText(value); } else { this.errors.push(`Enum member '${key}' must have an initializer at line ${member.line}, column ${member.column}`); code = 'undefined'; } if (value !== undefined) values.set(key, value); earlier.set(key, /^[\p{L}_$][\p{L}\p{N}\p{M}_$]*$/u.test(key) ? `${name}.${key}` : `${name}[${keyText}]`); previous = value; const stringMember = typeof value === 'string' || (member.initializer !== undefined && CodeGenerator.isSyntacticString(member.initializer)); return stringMember ? this.indent(`${name}[${keyText}] = ${code};`) : this.indent(`${name}[${name}[${keyText}] = ${code}] = ${keyText};`); }); this.indentLevel--; const body = lines.length > 0 ? `{\n${lines.join('\n')}\n${this.getIndent()}}` : '{}'; const iife = this.indent(`(function (${name}) ${body})(${name} || (${name} = {}));`); if (group && !this.declaresMergedBinding(node, group)) return iife; return [this.indent(`${keyword} ${name};`), iife].join('\n'); } /** * Whether `node` declares the binding of its merge group: the group's first * declaration that emits code (`эълон …` declarations emit none). */ declaresMergedBinding(node, group) { return group.declarations.find(d => !d.declare) === node; } /** Runs `generate` with earlier enum members readable by name (`Б = А + ф()`). */ withEnumMembers(members, generate) { const outer = this.enumMembers; this.enumMembers = new Map(members); try { return generate(); } finally { this.enumMembers = outer; } } /** * Whether an enum initializer is a string by its syntax: a string or template * literal, or `+` with one. As in TypeScript 6, such a member has no reverse * mapping also when its value is only known at run time (`` `${х}` ``). */ static isSyntacticString(expr) { if (expr.type === 'TemplateLiteral') return true; if (expr.type === 'Literal') return typeof expr.value === 'string'; if (expr.type !== 'BinaryExpression') return false; const binary = expr; return (binary.operator === '+' && (CodeGenerator.isSyntacticString(binary.left) || CodeGenerator.isSyntacticString(binary.right))); } enumValueText(value) { if (typeof value === 'string') return this.stringLiteral(value); return Object.is(value, -0) ? '-0' : String(value); } /** * Value of a constant enum initializer: number and string literals, `+ - ~`, * arithmetic, bitwise and `+` concatenation, and earlier members (`А`, * `Ранг.А`). Undefined when the value is only known at run time. */ enumConstant(expr, enumName, values) { const operand = (e) => this.enumConstant(e, enumName, values); switch (expr.type) { case 'Literal': { const { value, raw } = expr; if (typeof value === 'string') return value; return typeof value === 'number' && !/n$/.test(raw) ? value : undefined; } case 'TemplateLiteral': { // `матн ${А}`: a string when every substitution is a constant const template = expr; let text = template.quasis[0].value.cooked; for (const [index, substitution] of template.expressions.entries()) { const value = operand(substitution); if (value === undefined) return undefined; text += `${value}${template.quasis[index + 1].value.cooked}`; } return text; } case 'Identifier': return values.get((0, builtin_names_1.translateMemberName)(expr.name)); case 'MemberExpression': return CodeGenerator.enumMemberConstant(expr, enumName, values); case 'UnaryExpression': { const unary = expr; return CodeGenerator.foldUnary(unary.operator, operand(unary.argument)); } case 'BinaryExpression': { const binary = expr; return CodeGenerator.foldBinary(binary.operator, operand(binary.left), operand(binary.right)); } default: return undefined; } } /** `Ранг.А` / `Ранг["А"]` / `Ранг[\`А\`]` naming an earlier member of the enum `enumName`. */ static enumMemberConstant(member, enumName, values) { if (member.object.type !== 'Identifier' || member.object.name !== enumName) { return undefined; } if (!member.computed) { return values.get((0, builtin_names_1.translateMemberName)(member.property.name)); } const key = CodeGenerator.stringKey(member.property); return key === undefined ? undefined : values.get(key); } /** The text of a string literal or a template without substitutions, as TypeScript reads keys. */ static stringKey(expr) { if (expr.type === 'Literal') { const { value } = expr; return typeof value === 'string' ? value : undefined; } const template = expr; return expr.type === 'TemplateLiteral' && template.expressions.length === 0 ? template.quasis[0].value.cooked : undefined; } static foldUnary(operator, argument) { if (typeof argument !== 'number') return undefined; if (operator === '+') return argument; if (operator === '-') return -argument; return operator === '~' ? ~argument : undefined; } static foldBinary(operator, left, right) { if (left === undefined || right === undefined) return undefined; if (operator === '+') { return typeof left === 'number' && typeof right === 'number' ? left + right : `${left}${right}`; } if (typeof left !== 'number' || typeof right !== 'number') return undefined; return CodeGenerator.foldNumeric(operator, left, right); } static foldNumeric(operator, left, right) { switch (operator) { case '-': return left - right; case '*': return left * right; case '/': return left / right; case '%': return left % right; case '**': return left ** right; case '<<': return left << right; case '>>': return left >> right; case '>>>': return left >>> right; case '&': return left & right; case '|': return left | right; case '^': return left ^ right; default: return undefined; } } generateNamespaceDeclaration(node) { const group = this.mergeGroups.get(node); if (group) return this.generateMergedNamespace(node, group); // Generate namespace as an IIFE (Immediately Invoked Function Expression) const name = this.generateIdentifier(node.name, true); // A local binding, so the namespace never leaks into (or, in strict code, // fails on) the global scope let result = this.indent(`const ${name} = (function() {\n`); this.indentLevel++; result += this.indent(`const ${name} = {};\n`); // Generate namespace body const statements = node.body.statements; // The body shares the IIFE's scope with the `const ${name} = {}` above this.checkRedeclarations(statements, [node.name.name]); this.scopes.push(new Set(this.declaredNames(statements))); result += this.withFunctionBoundary(() => this.generateNamespaceBody(statements, name)); this.scopes.pop(); result += this.indent(`return ${name};\n`); this.indentLevel--; result += this.indent('})();\n'); return result; } /** The statements of a namespace block; exported members also become `Н.ном`. */ generateNamespaceBody(statements, name) { let result = ''; for (const stmt of statements) { const isExported = stmt.exported; // Skip interface declarations and type aliases - they don't generate runtime code if (stmt.type === 'InterfaceDeclaration' || stmt.type === 'TypeAlias') { result += this.generateStatement(stmt); continue; } const code = isExported ? this.generateExportedNamespaceMember(stmt, name) : this.generateStatement(stmt); result += code && !code.endsWith('\n') ? `${code}\n` : code; } return result; } /** * A namespace merged with other declarations of its name (another * `номфазо`, a class, function or enum), as TypeScript emits it: * * var Н; * (function (Н) { * const а = 1; * Н.а = а; * })(Н || (Н = {})); * * Members the group's other namespace blocks export are read as `Н.ном`. */ generateMergedNamespace(node, group) { const name = this.generateIdentifier(node.name, true); const keyword = this.scopes.length <= 1 ? 'var' : 'let'; const statements = node.body.statements; const own = new Set(this.declaredNames(statements)); const shared = new Set(); for (const other of group.declarations) { if (other === node || other.type !== 'NamespaceDeclaration') continue; for (const member of this.namespaceExports(other)) { if (!own.has(member)) shared.add(member); } } let result = ''; if (this.declaresMergedBinding(node, group)) result += this.indent(`${keyword} ${name};\n`); result += this.indent(`(function (${name}) {\n`); this.indentLevel++; this.checkRedeclarations(statements, [node.name.name]); this.scopes.push(new Set([node.name.name, ...own])); const outerMembers = this.namespaceMembers; this.namespaceMembers = { namespace: name, names: shared, depth: this.scopes.length - 1 }; try { result += this.withFunctionBoundary(() => this.generateNamespaceBody(statements, name)); } finally { this.namespaceMembers = outerMembers; this.scopes.pop(); this.indentLevel--; } return result + this.indent(`})(${name} || (${name} = {}));\n`); } /** Names a namespace block exports; in an `эълон номфазо` every declaration counts. */ namespaceExports(node) { const statements = node.body.statements; if (!node.declare) { return statements .filter(stmt => stmt.exported) .flatMap(stmt => this.getMemberNames(stmt)); } return statements.flatMap(stmt => stmt.type === 'FunctionSignature' ? [stmt.name.name] : this.getMemberNames(stmt)); } /** `ном` in a block of a merged namespace that another block exports: `Н.ном`. */ namespaceMemberReference(name) { const members = this.namespaceMembers; if (!members?.names.has(name)) return undefined; if (this.scopes.slice(members.depth).some(scope => scope.has(name))) return undefined; return `${members.namespace}.${(0, builtin_names_1.translateMemberName)(name)}`; } /** * An exported member of a namespace: its declaration, a local binding the * namespace's other members use (a nested namespace too), then * `Н.ном = ном;` for each name it binds. */ generateExportedNamespaceMember(stmt, namespaceName) { const code = this.generateStatement(stmt); // An ambient member (`содир эълон собит х: рақам;`) exists elsewhere if (!code.trim()) return code; const assignments = this.getMemberNames(stmt).map(name => this.indent(`${namespaceName}.${(0, builtin_names_1.translateMemberName)(name)} = ${name};\n`)); return `${withoutTrailingNewlines(code)}\n${assignments.join('')}`; } /** * Names an exported namespace member binds: one, each of `содир тағ а = 1, * б = 2`, or each name of a pattern (`содир собит { а, б: [в] } = о`). */ getMemberNames(stmt) { const names = []; this.collectDeclaredNames(stmt, names); return names; } generateClassDeclaration(node) { return this.indent(this.generateClass(node)); } /** `синф { … }` as an expression; its own name is in scope in its body only. */ generateClassExpression(node) { return this.withScope(node.name ? [node.name.name] : [], () => this.generateClass(node)); } /** * Decorators as written, `@ном(1) `, before a class, member or parameter; * TypeScript lowers them (see `LoweringNeeds`). */ generateDecorators(decorators) { if (!decorators || decorators.length === 0) return ''; this.lowering.decorators = true; return decorators .map(decorator => { const expression = this.generateExpression(decorator.expression); // `@а.б(1)` as is; anything else (`@(а[0])`) in parentheses return CodeGenerator.isDecoratorChain(decorator.expression, true) ? `@${expression} ` : `@(${expression}) `; }) .join(''); } /** `ном`, `а.б`, `а.б(1)`: a decorator JavaScript accepts without parentheses. */ static isDecoratorChain(expression, allowCall) { switch (expression.type) { case 'Identifier': return true; case 'MemberExpression': { const member = expression; return (!member.computed && !member.optional && CodeGenerator.isDecoratorChain(member.object, false)); } case 'CallExpression': { const call = expression; return allowCall && !call.optional && CodeGenerator.isDecoratorChain(call.callee, false); } default: return false; } } /** Standard decorators cannot decorate parameters; legacy ones (`experimentalDecorators`) can. */ checkParameterDecorators(param) { this.lowering.parameterDecorators = true; if (this.experimentalDecorators) return; const at = param.decorators[0]; this.errors.push(`Decorators are not valid here at line ${at.line}, column ${at.column}: parameter decorators need the 'experimentalDecorators' option`); } /** `class Ном extends Асос { … }`, members one level deeper than the current indentation. */ generateClass(node) { const decorators = this.generateDecorators(node.decorators); const className = node.name ? ` ${this.generateIdentifier(node.name, true)}` : ''; const typeParameters = this.typeParametersText(node.typeParameters); const extendsClause = node.superClass ? ` extends ${this.generateExpression(node.superClass, exports.PREC.CALL)}${this.typeArgumentsText(node.superTypeArguments)}` : ''; const implementsClause = this.implementsClause(node); // JavaScript has no abstract classes: only TypeScript output gets `abstract` (classModifiers) let classBody = ''; // Generate class members, one level deeper than the class if (node.body && node.body.body) { this.privateNames.push(this.declaredPrivateNames(node)); this.indentLevel++; const members = [ ...this.extraClassMembers(node), ...node.body.body.map(member => { if (member.type === 'MethodDefinition') return this.generateMethodDefinition(member); if (member.type === 'PropertyDefinition') return this.generatePropertyDefinition(member); return this.generateStaticBlock(member); }), ].filter((member) => member.length > 0); this.indentLevel--; this.privateNames.pop(); if (members.length > 0) { classBody = '\n' + members.join('\n') + '\n' + this.getIndent(); } } return `${decorators}${this.classModifiers(node)}class${className}${typeParameters}${extendsClause}${implementsClause} {${classBody}}`; } /** * `static { … }`: unlike a function body, `бозгашт` is not allowed; like * one, loops around the class are not jump targets. */ generateStaticBlock(node) { const block = { type: 'BlockStatement', body: node.body, line: node.line, column: node.column, }; // `нав.target` is allowed (and `беқимат`) in a static block const body = this.withNewTarget(() => this.withFunctionBoundary(() => { this.inStaticBlock = true; return this.generateBlockStatement(block); })); return this.indent(`static ${body}`); } /** * Private names a class declares. Declaring one twice is an early error, * except for a getter and a setter of the same name; overload signatures * (`#м(х: рақам): беджавоб;`) declare nothing. */ declaredPrivateNames(node) { const declared = new Map(); for (const member of node.body.body) { if (member.type === 'StaticBlock' || member.key?.type !== 'PrivateIdentifier') continue; if (member.type === 'MethodDefinition' && member.signature) continue; const name = member.key.name; const kind = member.type === 'MethodDefinition' ? member.kind : 'field'; const previous = declared.get(name); const accessorPair = (previous === 'get' && kind === 'set') || (previous === 'set' && kind === 'get'); if (previous !== undefined && !accessorPair) { this.errors.push(`Identifier '#${name}' has already been declared at line ${member.key.line}, column ${member.key.column}`); } declared.set(name, accessorPair ? 'pair' : kind); } return new Set(declared.keys()); } /** * A class member name: `#ном` as written, `[ифода]` for a computed name, a * string or number literal as is, other names through the member-name mapping. */ generateMemberKey(key, computed = false) { if (computed) return `[${this.generateExpression(key, exports.PREC.ASSIGNMENT)}]`; if (key.type === 'Literal') return this.generateLiteral(key); return this.markPosition(key, key.type === 'PrivateIdentifier' ? this.generatePrivateIdentifier(key) : (0, builtin_names_1.translateMemberName)(key.name)); } generateMethodDefinition(node) { // Abstract methods and signatures without a body (overloads, members of // an `эълон синф`) don't exist in JavaScript if (node.abstract || node.signature) return this.generateMethodSignature(node); // Method names follow the same member-name mapping as `obj.маълумот()` // call sites (`translateMemberName`), so declaration and use agree. const name = node.kind === 'constructor' ? 'constructor' : this.generateMemberKey(node.key, node.computed); const accessor = node.kind === 'get' || node.kind === 'set' ? `${node.kind} ` : ''; const methodName = `${accessor}${name}${this.optionalMark(node.optional)}`; // Decorators come before every modifier: `@д static м() {}` const modifiers = `${this.generateDecorators(node.decorators)}${this.memberModifiers(node)}`; const isAsync = node.value.async ? 'async ' : ''; const star = node.value.generator ? '*' : ''; const typeParameters = this.typeParametersText(node.value.typeParameters); const returnType = this.returnTypeText(node.value.returnType); const body = node.kind === 'constructor' ? this.constructorBody(node.value) : node.value.body; const { params, body: code } = this.withNewTarget(() => this.generateFunctionParts(node.value.params, body, node.value.async, node.value.thisType, { name: node.key.type === 'Identifier' ? node.key.name : undefined, generator: node.value.generator, })); return this.indent(`${modifiers}${isAsync}${star}${methodName}${typeParameters}(${params})${returnType} ${code}`); } /** * Body of a constructor. JavaScript has no parameter properties * (`конструктор(хосусӣ х: рақам)`), so their assignments are added to it. */ constructorBody(constructor) { return this.withParameterProperties(constructor); } /** * The constructor body with `this.х = х;` for each parameter property * (`конструктор(хосусӣ х: рақам)`), placed as TypeScript places them: at * the start, or right after the `супер(…)` call among the body's statements. */ withParameterProperties(constructor, include = () => true) { const assignments = constructor.params .filter(param => (param.accessibility || param.readonly || param.override) && include(param)) .map(param => { const { line, column } = param; const target = { type: 'MemberExpression', object: { type: 'ThisExpression', line, column }, property: { ...param.name }, computed: false, line, column, }; const assignment = { type: 'AssignmentExpression', left: target, operator: '=', right: param.name, line, column, }; return { type: 'ExpressionStatement', expression: assignment, line, column }; }); if (assignments.length === 0) return constructor.body; const statements = constructor.body.body; const superCall = statements.findIndex(statement => { const expression = statement.expression; return (statement.type === 'ExpressionStatement' && expression.type === 'CallExpression' && expression.callee.type === 'Super'); }); return { ...constructor.body, body: [ ...statements.slice(0, superCall + 1), ...assignments, ...statements.slice(superCall + 1), ], }; } generatePropertyDefinition(node) { // Index signatures, `эълон` and `мавҳум` fields only declare types if (node.indexSignature || node.declare || node.abstract) { return this.generateFieldSignature(node); } const propertyName = this.generateMemberKey(node.key, node.computed); const modifiers = this.memberModifiers(node); // `дастрасӣ ном = 1;`: an auto-accessor, lowered by TypeScript if (node.accessor) this.lowering.autoAccessors = true; const accessor = node.accessor ? 'accessor ' : ''; const type = `${this.optionalMark(node.optional)}${node.definite ? this.definiteMark() : ''}${this.typeAnnotationText(node.typeAnnotation)}`; // A field initializer may use `нав.target` (it is `беқимат` there) const value = node.value; const initializer = value ? ` = ${this.withNewTarget(() => this.generateExpression(value, exports.PREC.ASSIGNMENT))}` : ''; const decorators = this.generateDecorators(node.decorators); return this.indent(`${decorators}${modifiers}${accessor}${propertyName}${type}${initializer};`); } generateSwitchStatement(node) { const discriminant = this.generateExpression(node.discriminant); // Case labels one level deeper than `switch`, their statements two this.indentLevel++; const cases = node.cases .map((switchCase) => { const label = switchCase.test ? `case ${this.generateExpression(switchCase.test)}:` : 'default:'; this.indentLevel++; const consequent = this.generateStatements(switchCase.consequent); this.indentLevel--; return [this.indent(label), ...consequent].join('\n'); }) .join('\n'); this.indentLevel--; return this.indent(`switch (${discriminant}) {\n${cases}\n${this.getIndent()}}`); } // Pattern generation methods generatePattern(node) { switch (node.type) { case 'Identifier': return this.generateIdentifier(node, true); case 'AssignmentPattern': return `${this.generatePattern(node.left)} = ${this.generateExpression(node.right, exports.PREC.ASSIGNMENT)}`; case 'ArrayPattern': return this.generateArrayPattern(node); case 'ObjectPattern': return this.generateObjectPattern(node); case 'SpreadElement': case 'RestElement': return `...${this.generatePattern(node.argument)}`; default: // The parser makes no other patterns; a syntax tree made elsewhere may this.errors.push(`Unknown pattern type: ${node.type}`); return ''; } } generateArrayPattern(node) { const elements = node.elements .map(element => { return element === null ? '' : this.generatePattern(element); }) .join(', '); return `[${elements}]`; } generateObjectPattern(node) { const properties = node.properties .map(prop => { return prop.type === 'SpreadElement' ? this.generatePattern(prop) : this.generatePropertyPattern(prop); }) .join(', '); return `{${properties}}`; } generatePropertyPattern(node) { const key = node.computed ? `[${this.generateExpression(node.key, exports.PREC.ASSIGNMENT)}]` : this.generatePropertyKey(node.key); // Shorthand `{ п }` binds a variable named like the key const value = node.value ?? node.key; const local = this.generatePattern(value); return !node.computed && stripPositionMarkers(local) === stripPositionMarkers(key) ? local : `${key}: ${local}`; } generateSpreadElement(node) { const argument = this.generateExpression(node.argument, exports.PREC.ASSIGNMENT); return `...${argument}`; } indent(text) { return this.getIndent() + text; } getIndent() { return ' '.repeat(this.indentLevel * this.indentSize); } } exports.CodeGenerator = CodeGenerator; }, {"./builtin-names":"builtin-names.js"}, ], "diagnostics/catalog-learner.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.LEARNER_MESSAGES = void 0; /** * Warnings of the learning mode (`"режим": "таълимӣ"` in somon.config.json, * the playground's «Реҷаи таълимӣ»; src/learner/warnings.ts): mistakes a * beginner makes that are valid JavaScript, and so no error. */ const text_1 = require("./text"); exports.LEARNER_MESSAGES = { LEARNER_STRING_ARITHMETIC: { en: p => `${(0, text_1.code)(p.operator)} computes with a ${(0, text_1.code)('сатр')}: it is turned into a number, and the result may be ${(0, text_1.code)('ғайрирақам')}. Read numbers with ${(0, text_1.code)('хонданиРақам()')}.`, ru: p => `${(0, text_1.code)(p.operator)} вычисляет со строкой: она превращается в число, и результат может оказаться ${(0, text_1.code)('ғайрирақам')} («не число»). Числа читайте через ${(0, text_1.code)('хонданиРақам()')}.`, tj: p => `Амали ${(0, text_1.code)(p.operator)} бо сатр ҳисоб мекунад: сатр ба рақам табдил меёбад ва натиҷа метавонад ${(0, text_1.code)('ғайрирақам')} шавад. Рақамҳоро бо ${(0, text_1.code)('хонданиРақам()')} хонед.`, }, LEARNER_STRING_PLUS_NUMBER: { en: () => `A line read with ${(0, text_1.code)('хондан()')} is a ${(0, text_1.code)('сатр')}: ${(0, text_1.code)('+')} joins it with the number instead of adding (${(0, text_1.code)('"2" + 3')} is ${(0, text_1.code)('"23"')}). Read numbers with ${(0, text_1.code)('хонданиРақам()')}.`, ru: () => `Строка, прочитанная через ${(0, text_1.code)('хондан()')}, - это ${(0, text_1.code)('сатр')}: ${(0, text_1.code)('+')} соединяет её с числом, а не складывает (${(0, text_1.code)('"2" + 3')} - это ${(0, text_1.code)('"23"')}). Числа читайте через ${(0, text_1.code)('хонданиРақам()')}.`, tj: () => `Сатре, ки бо ${(0, text_1.code)('хондан()')} хонда шудааст, ${(0, text_1.code)('сатр')} аст: ${(0, text_1.code)('+')} онро бо рақам ҷамъ намекунад, балки мепайвандад (${(0, text_1.code)('"2" + 3')} - ${(0, text_1.code)('"23"')}). Рақамҳоро бо ${(0, text_1.code)('хонданиРақам()')} хонед.`, }, LEARNER_COMPARE_TYPES: { en: p => `A ${(0, text_1.code)(p.left)} is compared with a ${(0, text_1.code)(p.right)}: values of different types are never equal, ${(0, text_1.code)(`${(0, text_1.text)(p.operator)}`)} is always the same.`, ru: p => `${(0, text_1.code)(p.left)} сравнивается с ${(0, text_1.code)(p.right)}: значения разных типов никогда не равны, и ${(0, text_1.code)(`${(0, text_1.text)(p.operator)}`)} всегда даёт одно и то же.`, tj: p => `${(0, text_1.code)(p.left)} бо ${(0, text_1.code)(p.right)} муқоиса мешавад: қиматҳои навъҳои гуногун ҳеҷ гоҳ баробар нестанд ва ${(0, text_1.code)(`${(0, text_1.text)(p.operator)}`)} ҳамеша як натиҷа медиҳад.`, }, LEARNER_UNUSED_VARIABLE: { en: p => `The variable ${(0, text_1.code)(p.name)} is declared but never used.`, ru: p => `Переменная ${(0, text_1.code)(p.name)} объявлена, но не используется.`, tj: p => `Тағйирёбандаи ${(0, text_1.code)(p.name)} эълон шудааст, вале истифода намешавад.`, }, LEARNER_BUILTIN_MEMBER_NAME: { en: p => `${(0, text_1.code)(p.name)} is the name of a built-in member: in JavaScript this property is called ${(0, text_1.code)(p.js)}, and it is printed so. Choose another name.`, ru: p => `${(0, text_1.code)(p.name)} - имя встроенного члена: в JavaScript это свойство называется ${(0, text_1.code)(p.js)} и так и выводится. Выберите другое имя.`, tj: p => `${(0, text_1.code)(p.name)} номи узви дарунсохт аст: дар JavaScript ин хосият ${(0, text_1.code)(p.js)} ном дорад ва ҳангоми чоп ҳамин тавр нишон дода мешавад. Номи дигар интихоб кунед.`, }, }; }, {"./text":"diagnostics/text.js"}, ], "diagnostics/catalog-program.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.HINTS = exports.PROGRAM_MESSAGES = void 0; /** * Messages of the stages after parsing (the code generator, the target check, * the options) and of the module system, and the hints that follow messages. */ const text_1 = require("./text"); exports.PROGRAM_MESSAGES = { CODEGEN_REDECLARED: { en: p => `${(0, text_1.code)(p.name)} has already been declared.`, ru: p => `Имя ${(0, text_1.code)(p.name)} уже объявлено.`, tj: p => `Номи ${(0, text_1.code)(p.name)} аллакай эълон шудааст.`, }, CODEGEN_RESERVED_WORD: { en: p => `${(0, text_1.code)(p.name)} is a reserved word of JavaScript and cannot be a name.`, ru: p => `${(0, text_1.code)(p.name)} - зарезервированное слово JavaScript, его нельзя использовать как имя.`, tj: p => `${(0, text_1.code)(p.name)} калимаи махсуси JavaScript аст ва онро ҳамчун ном истифода бурдан мумкин нест.`, }, 'CODEGEN_OUTSIDE_LOOP.break': { en: () => `${(0, text_1.code)('шикастан')} can only be used inside a loop or ${(0, text_1.code)('интихоб')}.`, ru: () => `${(0, text_1.code)('шикастан')} можно писать только внутри цикла или ${(0, text_1.code)('интихоб')}.`, tj: () => `${(0, text_1.code)('шикастан')}-ро танҳо дар дохили давра ё ${(0, text_1.code)('интихоб')} навиштан мумкин аст.`, }, 'CODEGEN_OUTSIDE_LOOP.continue': { en: () => `${(0, text_1.code)('давом')} can only be used inside a loop.`, ru: () => `${(0, text_1.code)('давом')} можно писать только внутри цикла.`, tj: () => `${(0, text_1.code)('давом')}-ро танҳо дар дохили давра навиштан мумкин аст.`, }, CODEGEN_AWAIT_OUTSIDE_ASYNC: { en: () => `${(0, text_1.code)('интизор')} can only be used inside a ${(0, text_1.code)('ҳамзамон')} function.`, ru: () => `${(0, text_1.code)('интизор')} можно писать только внутри функции ${(0, text_1.code)('ҳамзамон')}.`, tj: () => `${(0, text_1.code)('интизор')}-ро танҳо дар дохили функсияи ${(0, text_1.code)('ҳамзамон')} навиштан мумкин аст.`, }, CODEGEN_INVALID_LABEL: { en: p => (0, text_1.text)(p.detail), ru: p => `Метка ${(0, text_1.code)(p.name)} использована неправильно.`, tj: p => `Нишонаи ${(0, text_1.code)(p.name)} нодуруст истифода шудааст.`, }, CODEGEN_INVALID: { en: p => (0, text_1.text)(p.detail), ru: () => 'Эту часть программы нельзя перевести в JavaScript.', tj: () => 'Ин қисми барномаро ба JavaScript табдил додан мумкин нест.', }, TARGET_UNSUPPORTED: { en: p => (0, text_1.text)(p.detail), ru: () => 'Эта конструкция недоступна в выбранной версии JavaScript.', tj: () => 'Ин сохтор дар версияи интихобшудаи JavaScript дастрас нест.', }, BROWSER_NEEDS_TYPESCRIPT: { en: p => (0, text_1.text)(p.detail), ru: () => `Эту программу нельзя выполнить в браузере: декораторы, ${(0, text_1.code)('дастрасӣ')} и ${(0, text_1.code)('истифода')} здесь не работают. Запустите её через ${(0, text_1.code)('somon run')}.`, tj: () => `Ин барномаро дар браузер иҷро кардан мумкин нест: декораторҳо, ${(0, text_1.code)('дастрасӣ')} ва ${(0, text_1.code)('истифода')} дар ин ҷо кор намекунанд. Онро бо ${(0, text_1.code)('somon run')} иҷро кунед.`, }, OPTION_INVALID: { en: p => (0, text_1.text)(p.detail), ru: () => 'Неправильная настройка компилятора.', tj: () => 'Танзимоти компилятор нодуруст аст.', }, MODULE_NOT_FOUND: { en: p => `Cannot find the module ${(0, text_1.code)(p.specifier)}.`, ru: p => `Модуль ${(0, text_1.code)(p.specifier)} не найден.`, tj: p => `Модули ${(0, text_1.code)(p.specifier)} ёфт нашуд.`, }, MODULE_FILE_NOT_FOUND: { en: p => `Cannot find the file ${(0, text_1.code)(p.file)}.`, ru: p => `Файл ${(0, text_1.code)(p.file)} не найден.`, tj: p => `Файли ${(0, text_1.code)(p.file)} ёфт нашуд.`, }, CIRCULAR_DEPENDENCY: { en: p => `Modules import each other in a circle: ${(0, text_1.code)(p.cycle)}.`, ru: p => `Модули импортируют друг друга по кругу: ${(0, text_1.code)(p.cycle)}.`, tj: p => `Модулҳо якдигарро даврвор ворид мекунанд: ${(0, text_1.code)(p.cycle)}.`, }, MODULE_ERROR: { en: p => (0, text_1.text)(p.detail), ru: () => 'Модуль не удалось загрузить.', tj: () => 'Модулро бор кардан нашуд.', }, }; /** Advice after a message (`Diagnostic.hint`). */ exports.HINTS = { DID_YOU_MEAN: { en: p => `Did you mean ${(0, text_1.code)(p.name)}?`, ru: p => `Может быть, вы имели в виду ${(0, text_1.code)(p.name)}?`, tj: p => `Шояд ${(0, text_1.code)(p.name)}-ро дар назар доштед?`, }, ENGLISH_KEYWORD: { en: p => `Write ${(0, text_1.code)(p.tajik)} instead of ${(0, text_1.code)(p.english)}.`, ru: p => `Вместо ${(0, text_1.code)(p.english)} пишите ${(0, text_1.code)(p.tajik)}.`, tj: p => `Ба ҷои ${(0, text_1.code)(p.english)} ${(0, text_1.code)(p.tajik)} нависед.`, }, DECLARE_FIRST: { en: () => `Declare it with ${(0, text_1.code)('тағ')} or ${(0, text_1.code)('собит')} before using it.`, ru: () => `Объявите его через ${(0, text_1.code)('тағ')} или ${(0, text_1.code)('собит')} до использования.`, tj: () => `Пеш аз истифода онро бо ${(0, text_1.code)('тағ')} ё ${(0, text_1.code)('собит')} эълон кунед.`, }, ARGUMENT_COMMA: { en: () => `Separate arguments with a comma: ${(0, text_1.code)('чоп(1, 2)')}.`, ru: () => `Разделяйте аргументы запятой: ${(0, text_1.code)('чоп(1, 2)')}.`, tj: () => `Аргументҳоро бо вергул ҷудо кунед: ${(0, text_1.code)('чоп(1, 2)')}.`, }, FOR_SEMICOLONS: { en: () => `Separate the parts of ${(0, text_1.code)('барои')} with ${(0, text_1.code)(';')}: ${(0, text_1.code)('барои (тағ и = 0; и < 5; и++)')}.`, ru: () => `Части ${(0, text_1.code)('барои')} разделяются знаком ${(0, text_1.code)(';')}: ${(0, text_1.code)('барои (тағ и = 0; и < 5; и++)')}.`, tj: () => `Қисмҳои ${(0, text_1.code)('барои')}-ро бо ${(0, text_1.code)(';')} ҷудо кунед: ${(0, text_1.code)('барои (тағ и = 0; и < 5; и++)')}.`, }, USE_TAG: { en: () => `If the value must change, declare it with ${(0, text_1.code)('тағ')}.`, ru: () => `Если значение должно меняться, объявите его через ${(0, text_1.code)('тағ')}.`, tj: () => `Агар қимат бояд иваз шавад, онро бо ${(0, text_1.code)('тағ')} эълон кунед.`, }, NO_REDECLARE: { en: p => `To change its value, do not repeat ${(0, text_1.code)('тағ')}: write ${(0, text_1.code)(`${(0, text_1.text)(p.name)} = …`)}.`, ru: p => `Чтобы изменить значение, не повторяйте ${(0, text_1.code)('тағ')}: напишите ${(0, text_1.code)(`${(0, text_1.text)(p.name)} = …`)}.`, tj: p => `Барои иваз кардани қимат ${(0, text_1.code)('тағ')}-ро такрор накунед: ${(0, text_1.code)(`${(0, text_1.text)(p.name)} = …`)} нависед.`, }, TRIPLE_QUOTES: { en: p => `SomonScript has no ${(0, text_1.code)(p.quotes)}. Write text of several lines between backticks (the key left of 1 in the English layout), or print each line with its own ${(0, text_1.code)('чоп')}.`, ru: p => `В этом языке нет ${(0, text_1.code)(p.quotes)}. Текст в несколько строк пишите между обратными кавычками (клавиша слева от 1 в английской раскладке) или печатайте каждую строку своим ${(0, text_1.code)('чоп')}.`, tj: p => `Ин забон ${(0, text_1.code)(p.quotes)} надорад. Матни якчандсатраро байни нохунакҳои баръакс нависед (тугмаи пеш аз 1 дар клавиатураи англисӣ) ё ҳар сатрро бо ${(0, text_1.code)('чоп')}-и алоҳида чоп кунед.`, }, NUMBER_IN_QUOTES: { en: p => `Write the number without quotes: ${(0, text_1.code)(p.value)}.`, ru: p => `Пишите число без кавычек: ${(0, text_1.code)(p.value)}.`, tj: p => `Рақамро бе нохунак нависед: ${(0, text_1.code)(p.value)}.`, }, HAS_FOR_MAP_SET: { en: () => `Use ${(0, text_1.code)('дорадКалид')} to test whether a value is there.`, ru: () => `Чтобы проверить, есть ли значение, используйте ${(0, text_1.code)('дорадКалид')}.`, tj: () => `Барои санҷидани он ки қимат ҳаст ё не, ${(0, text_1.code)('дорадКалид')}-ро истифода баред.`, }, RENAME: { en: () => 'Choose another name.', ru: () => 'Выберите другое имя.', tj: () => 'Номи дигар интихоб кунед.', }, CHECK_PATH: { en: () => 'Check the path and the name of the file.', ru: () => 'Проверьте путь и имя файла.', tj: () => 'Роҳ ва номи файлро санҷед.', }, }; }, {"./text":"diagnostics/text.js"}, ], "diagnostics/catalog-runtime.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.RUNTIME_HINTS = exports.RUNTIME_MESSAGES = void 0; /** * Messages for errors of a running program (src/runtime/errors.ts tells what * an error is about): reading a member of `беқимат`, a name that is not * defined, calling what is no function, endless recursion, … and the errors a * program throws itself with `партофтан`. */ const text_1 = require("./text"); exports.RUNTIME_MESSAGES = { RUNTIME_READ_OF_NOTHING: { en: p => `Cannot read the property ${(0, text_1.code)(p.property)}: the value is ${(0, text_1.code)(p.value)}.`, ru: p => `Нельзя прочитать свойство ${(0, text_1.code)(p.property)}: значение - ${(0, text_1.code)(p.value)}.`, tj: p => `Хосияти ${(0, text_1.code)(p.property)}-ро хондан мумкин нест: қимат ${(0, text_1.code)(p.value)} аст.`, }, RUNTIME_WRITE_TO_NOTHING: { en: p => `Cannot set the property ${(0, text_1.code)(p.property)}: the value is ${(0, text_1.code)(p.value)}.`, ru: p => `Нельзя задать свойство ${(0, text_1.code)(p.property)}: значение - ${(0, text_1.code)(p.value)}.`, tj: p => `Ба хосияти ${(0, text_1.code)(p.property)} қимат додан мумкин нест: объект ${(0, text_1.code)(p.value)} аст.`, }, RUNTIME_NOT_DEFINED: { en: p => `${(0, text_1.code)(p.name)} is not defined.`, ru: p => `Имя ${(0, text_1.code)(p.name)} не определено.`, tj: p => `Номи ${(0, text_1.code)(p.name)} муайян нашудааст.`, }, RUNTIME_BEFORE_DECLARATION: { en: p => `${(0, text_1.code)(p.name)} is used before it is declared.`, ru: p => `${(0, text_1.code)(p.name)} используется раньше, чем объявлено.`, tj: p => `${(0, text_1.code)(p.name)} пеш аз эълон шуданаш истифода шудааст.`, }, RUNTIME_NOT_A_FUNCTION: { en: p => `${(0, text_1.code)(p.name)} is not a function and cannot be called.`, ru: p => `${(0, text_1.code)(p.name)} - не функция, её нельзя вызвать.`, tj: p => `${(0, text_1.code)(p.name)} функсия нест ва онро даъват кардан мумкин нест.`, }, RUNTIME_NOT_A_CONSTRUCTOR: { en: p => `${(0, text_1.code)(p.name)} cannot be used with ${(0, text_1.code)('нав')}.`, ru: p => `${(0, text_1.code)(p.name)} нельзя использовать с ${(0, text_1.code)('нав')}.`, tj: p => `${(0, text_1.code)(p.name)}-ро бо ${(0, text_1.code)('нав')} истифода бурдан мумкин нест.`, }, RUNTIME_NOT_ITERABLE: { en: p => `${(0, text_1.code)(p.name)} is not a list: ${(0, text_1.code)('барои … аз')} cannot go through it.`, ru: p => `${(0, text_1.code)(p.name)} - не список: ${(0, text_1.code)('барои … аз')} не может по нему пройти.`, tj: p => `${(0, text_1.code)(p.name)} рӯйхат нест: ${(0, text_1.code)('барои … аз')} аз он гузашта наметавонад.`, }, RUNTIME_STACK_OVERFLOW: { en: () => 'Functions called each other too deeply. Maybe a function calls itself without end?', ru: () => 'Функции вызвали друг друга слишком глубоко. Может быть, функция вызывает сама себя без конца?', tj: () => 'Функсияҳо якдигарро аз ҳад зиёд амиқ даъват карданд. Шояд функсия худашро беохир даъват мекунад?', }, RUNTIME_INVALID_ARRAY_LENGTH: { en: () => 'Invalid length of a list: it must be a whole number, 0 or more.', ru: () => 'Неправильная длина массива: это должно быть целое число, не меньше 0.', tj: () => 'Дарозии рӯйхат нодуруст аст: он бояд рақами бутун, аз 0 зиёд ё баробар бошад.', }, RUNTIME_CONST_ASSIGNMENT: { en: () => `A ${(0, text_1.code)('собит')} cannot get a new value.`, ru: () => `Значению ${(0, text_1.code)('собит')} нельзя присвоить новое значение.`, tj: () => `Ба ${(0, text_1.code)('собит')} қимати нав додан мумкин нест.`, }, RUNTIME_INPUT_ENDED: { en: p => `The input ended: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} expected another line.`, ru: p => `Ввод закончился: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} ждала ещё одну строку.`, tj: p => `Вуруд тамом шуд: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} боз як сатр интизор буд.`, }, RUNTIME_INPUT_NOT_A_NUMBER: { en: p => `${p.text === '' ? 'An empty line' : (0, text_1.code)(p.text)} is not a number: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} expected one.`, ru: p => `${p.text === '' ? 'Пустая строка' : (0, text_1.code)(p.text)} - не число: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} ждала число.`, tj: p => `${p.text === '' ? 'Сатри холӣ' : (0, text_1.code)(p.text)} рақам нест: ${(0, text_1.code)(`${(0, text_1.text)(p.name)}()`)} рақам интизор буд.`, }, RUNTIME_NO_MODULES: { en: p => `The playground cannot import the module ${(0, text_1.code)(p.name)}: write the whole program in one file.`, ru: p => `В песочнице нельзя подключить модуль ${(0, text_1.code)(p.name)}: напишите всю программу в одном файле.`, tj: p => `Дар майдони озмоиш модули ${(0, text_1.code)(p.name)}-ро ворид кардан мумкин нест: тамоми барномаро дар як файл нависед.`, }, INPUT_ASK_AGAIN: { en: p => `${p.text === '' ? 'That' : (0, text_1.code)(p.text)} is not a number. Type a number again:`, ru: p => `${p.text === '' ? 'Это' : (0, text_1.code)(p.text)} - не число. Введите число ещё раз:`, tj: p => `${p.text === '' ? 'Ин' : (0, text_1.code)(p.text)} рақам нест. Боз як бор рақам нависед:`, }, RUNTIME_THROWN: { en: p => `The program threw an error: ${(0, text_1.text)(p.message)}`, ru: p => `Программа выбросила ошибку: ${(0, text_1.text)(p.message)}`, tj: p => `Барнома хато партофт: ${(0, text_1.text)(p.message)}`, }, RUNTIME_ERROR: { en: p => `${(0, text_1.text)(p.name)}: ${(0, text_1.text)(p.message)}`, ru: p => `Ошибка во время выполнения: ${(0, text_1.text)(p.name)}: ${(0, text_1.text)(p.message)}`, tj: p => `Ҳангоми иҷро хато рух дод: ${(0, text_1.text)(p.name)}: ${(0, text_1.text)(p.message)}`, }, }; /** Advice after a run-time error. */ exports.RUNTIME_HINTS = { INDEX_OUT_OF_RANGE: { en: () => `Maybe the list has no element at this index: indexes go from 0 to ${(0, text_1.code)('дарозӣ - 1')}.`, ru: () => `Может быть, в массиве нет элемента с таким индексом: индексы идут от 0 до ${(0, text_1.code)('дарозӣ - 1')}.`, tj: () => `Шояд дар рӯйхат унсуре бо ин индекс нест: индексҳо аз 0 то ${(0, text_1.code)('дарозӣ - 1')} мебошанд.`, }, CHECK_VALUE: { en: p => `Check that the value is not ${(0, text_1.code)(p.value)} before using it.`, ru: p => `Перед использованием проверьте, что значение не ${(0, text_1.code)(p.value)}.`, tj: p => `Пеш аз истифода санҷед, ки қимат ${(0, text_1.code)(p.value)} нест.`, }, STOP_CONDITION: { en: () => `A function that calls itself needs a condition that stops it: ${(0, text_1.code)('агар (н <= 1) бозгашт 1;')}`, ru: () => `Функции, которая вызывает сама себя, нужно условие остановки: ${(0, text_1.code)('агар (н <= 1) бозгашт 1;')}`, tj: () => `Функсияе, ки худашро даъват мекунад, шарти қатъ лозим дорад: ${(0, text_1.code)('агар (н <= 1) бозгашт 1;')}`, }, DECLARE_BEFORE_USE: { en: () => 'Move the declaration above the line that uses the name.', ru: () => 'Перенесите объявление выше строки, где используется имя.', tj: () => 'Эълонро аз сатре, ки номро истифода мебарад, болотар гузоред.', }, INPUT_LINES: { en: () => 'Give the program as many lines of input as it reads.', ru: () => 'Дайте программе столько строк ввода, сколько она читает.', tj: () => 'Ба барнома ҳамон қадар сатри вуруд диҳед, ки он мехонад.', }, INPUT_NUMBER: { en: () => `Write a number in this line of the input, such as ${(0, text_1.code)('42')} or ${(0, text_1.code)('2,5')}.`, ru: () => `Напишите в этой строке ввода число, например ${(0, text_1.code)('42')} или ${(0, text_1.code)('2,5')}.`, tj: () => `Дар ин сатри вуруд рақам нависед, масалан ${(0, text_1.code)('42')} ё ${(0, text_1.code)('2,5')}.`, }, SHOW_STACK: { en: () => `${(0, text_1.code)('somon run --stack')} shows where the error came from in full.`, ru: () => `${(0, text_1.code)('somon run --стек')} покажет полный путь вызовов.`, tj: () => `${(0, text_1.code)('somon run --стек')} пайҷои пурраи даъватҳоро нишон медиҳад.`, }, }; }, {"./text":"diagnostics/text.js"}, ], "diagnostics/catalog-syntax.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.SYNTAX_MESSAGES = void 0; /** * Messages for code that cannot be read: the lexer's and the parser's errors, * after src/diagnostics/classify.ts has told what they are about. These are * written for learners in every language; `compile()` without a language * still returns the parser's own English text. */ const text_1 = require("./text"); /** What a parameter `found` shows: the token, or the end of the program. */ function found(p, endOfProgram) { return p.found === undefined ? endOfProgram : (0, text_1.code)(p.found); } /** Where the bracket being closed was opened, as the second sentence of a message. */ function opened(p, sameLine, onLine) { if (p.openLine === undefined) return ''; return p.openLine === p.line ? ` ${sameLine}` : ` ${onLine.replace('{0}', (0, text_1.text)(p.openLine))}`; } /** Names the parser expects, by kind (`PARSE_EXPECTED_NAME`). */ const NAMES = { variable: { en: 'a variable name', ru: 'имя переменной', tj: 'номи тағйирёбанда' }, property: { en: 'a property name', ru: 'имя свойства', tj: 'номи хосият' }, identifier: { en: 'a name', ru: 'имя', tj: 'ном' }, function: { en: 'a function name', ru: 'имя функции', tj: 'номи функсия' }, module: { en: 'a module path in quotes', ru: 'путь к модулю в кавычках', tj: 'роҳи модул дар нохунак', }, enumMember: { en: 'the name of an enum member', ru: 'имя элемента перечисления', tj: 'номи узви шумориш', }, namespace: { en: 'a namespace name', ru: 'имя пространства имён', tj: 'номи номфазо' }, class: { en: 'a class name', ru: 'имя класса', tj: 'номи синф' }, decorator: { en: 'a decorator name', ru: 'имя декоратора', tj: 'номи декоратор' }, type: { en: 'a type name', ru: 'имя типа', tj: 'номи навъ' }, declaration: { en: 'a declaration', ru: 'объявление', tj: 'эълон' }, }; function nameOf(p, language) { return (NAMES[(0, text_1.text)(p.what)] ?? NAMES.identifier)[language]; } exports.SYNTAX_MESSAGES = { PARSE_MISSING_CLOSE: { en: p => `Missing closing ${(0, text_1.code)(p.close)}.${opened(p, `The ${(0, text_1.code)(p.open)} was opened on this line.`, `The ${(0, text_1.code)(p.open)} was opened on line {0}.`)}`, ru: p => `Не хватает закрывающей скобки ${(0, text_1.code)(p.close)}.${opened(p, `Скобка ${(0, text_1.code)(p.open)} открыта в этой же строке.`, `Скобка ${(0, text_1.code)(p.open)} открыта в строке {0}.`)}`, tj: p => `Қавси пӯшандаи ${(0, text_1.code)(p.close)} намерасад.${opened(p, `Қавси ${(0, text_1.code)(p.open)} дар ҳамин сатр кушода шудааст.`, `Қавси ${(0, text_1.code)(p.open)} дар сатри {0} кушода шудааст.`)}`, }, PARSE_UNMATCHED_CLOSE: { en: p => `Unexpected ${(0, text_1.code)(p.close)}: there is no opening bracket for it.`, ru: p => `Лишняя скобка ${(0, text_1.code)(p.close)}: для неё нет открывающей.`, tj: p => `Қавси ${(0, text_1.code)(p.close)} зиёдатӣ аст: барои он қавси кушода нест.`, }, PARSE_EXPECTED_OPEN: { en: p => p.after === undefined ? `Expected ${(0, text_1.code)(p.open)} here.` : `Expected ${(0, text_1.code)(p.open)} after ${(0, text_1.code)(p.after)}.`, ru: p => p.after === undefined ? `Здесь нужна скобка ${(0, text_1.code)(p.open)}.` : `После ${(0, text_1.code)(p.after)} нужна скобка ${(0, text_1.code)(p.open)}.`, tj: p => p.after === undefined ? `Дар ин ҷо қавси ${(0, text_1.code)(p.open)} лозим аст.` : `Пас аз ${(0, text_1.code)(p.after)} қавси ${(0, text_1.code)(p.open)} лозим аст.`, }, PARSE_CONDITION_PARENS: { en: p => `Expected ${(0, text_1.code)('(')} after ${(0, text_1.code)(p.keyword)}. For example: ${(0, text_1.code)(p.example)}`, ru: p => `После ${(0, text_1.code)(p.keyword)} нужна скобка ${(0, text_1.code)('(')}. Например: ${(0, text_1.code)(p.example)}`, tj: p => `Пас аз ${(0, text_1.code)(p.keyword)} қавси ${(0, text_1.code)('(')} лозим аст. Масалан: ${(0, text_1.code)(p.example)}`, }, PARSE_EXPECTED_SEMICOLON: { en: p => p.found === undefined ? `Expected ${(0, text_1.code)(';')} at the end of the program.` : `Unexpected ${(0, text_1.code)(p.found)}: a ${(0, text_1.code)(';')} may be missing before it.`, ru: p => p.found === undefined ? `В конце программы не хватает ${(0, text_1.code)(';')}.` : `Здесь не ожидалось ${(0, text_1.code)(p.found)}: возможно, перед ним не хватает ${(0, text_1.code)(';')}.`, tj: p => p.found === undefined ? `Дар охири барнома ${(0, text_1.code)(';')} намерасад.` : `Дар ин ҷо ${(0, text_1.code)(p.found)} интизор набуд: шояд пеш аз он ${(0, text_1.code)(';')} намерасад.`, }, PARSE_EXPECTED_TOKEN: { en: p => `Expected ${(0, text_1.codes)(p.expected, 'en')} here, but found ${found(p, 'the end of the program')}.`, ru: p => p.found === undefined ? `Здесь нужно ${(0, text_1.codes)(p.expected, 'ru')}, но программа закончилась.` : `Здесь нужно ${(0, text_1.codes)(p.expected, 'ru')}, а написано ${(0, text_1.code)(p.found)}.`, tj: p => p.found === undefined ? `Дар ин ҷо ${(0, text_1.codes)(p.expected, 'tj')} лозим аст, вале барнома тамом шуд.` : `Дар ин ҷо ${(0, text_1.codes)(p.expected, 'tj')} лозим аст, вале ${(0, text_1.code)(p.found)} навишта шудааст.`, }, PARSE_EXPECTED_NAME: { en: p => `Expected ${nameOf(p, 'en')} here, but found ${found(p, 'the end of the program')}.`, ru: p => p.found === undefined ? `Здесь нужно ${nameOf(p, 'ru')}, но программа закончилась.` : `Здесь нужно ${nameOf(p, 'ru')}, а написано ${(0, text_1.code)(p.found)}.`, tj: p => p.found === undefined ? `Дар ин ҷо ${nameOf(p, 'tj')} лозим аст, вале барнома тамом шуд.` : `Дар ин ҷо ${nameOf(p, 'tj')} лозим аст, вале ${(0, text_1.code)(p.found)} навишта шудааст.`, }, PARSE_EXPECTED_EXPRESSION: { en: p => `Expected a value or an expression here, but found ${found(p, 'the end of the program')}.`, ru: p => p.found === undefined ? 'Здесь нужно значение или выражение, но программа закончилась.' : `Здесь нужно значение или выражение, а написано ${(0, text_1.code)(p.found)}.`, tj: p => p.found === undefined ? 'Дар ин ҷо қимат ё ифода лозим аст, вале барнома тамом шуд.' : `Дар ин ҷо қимат ё ифода лозим аст, вале ${(0, text_1.code)(p.found)} навишта шудааст.`, }, PARSE_UNEXPECTED_TOKEN: { en: p => `Unexpected ${found(p, 'end of the program')} here.`, ru: p => `Здесь не ожидалось ${found(p, 'конца программы')}.`, tj: p => p.found === undefined ? 'Барнома дар ин ҷо бояд тамом намешуд.' : `Дар ин ҷо ${(0, text_1.code)(p.found)} интизор набуд.`, }, PARSE_DUPLICATE_DEFAULT_CASE: { en: () => `A ${(0, text_1.code)('интихоб')} can have only one ${(0, text_1.code)('пешфарз')} case.`, ru: () => `В ${(0, text_1.code)('интихоб')} может быть только один ${(0, text_1.code)('пешфарз')}.`, tj: () => `Дар ${(0, text_1.code)('интихоб')} танҳо як ${(0, text_1.code)('пешфарз')} буда метавонад.`, }, PARSE_SHORTHAND_INITIALIZER: { en: () => `In an object, write ${(0, text_1.code)(':')} after a property name, not ${(0, text_1.code)('=')}: ${(0, text_1.code)('{ ном: қимат }')}.`, ru: () => `В объекте после имени свойства пишите ${(0, text_1.code)(':')}, а не ${(0, text_1.code)('=')}: ${(0, text_1.code)('{ ном: қимат }')}.`, tj: () => `Дар объект пас аз номи хосият ${(0, text_1.code)(':')} нависед, на ${(0, text_1.code)('=')}: ${(0, text_1.code)('{ ном: қимат }')}.`, }, PARSE_INVALID_MODIFIER: { en: p => (0, text_1.text)(p.detail), ru: p => `Слово ${(0, text_1.code)(p.modifier)} здесь использовать нельзя.`, tj: p => `Калимаи ${(0, text_1.code)(p.modifier)}-ро дар ин ҷо истифода бурдан мумкин нест.`, }, PARSE_INVALID_DECLARATION: { en: p => (0, text_1.text)(p.detail), ru: () => 'Такое объявление здесь недопустимо.', tj: () => 'Чунин эълон дар ин ҷо нодуруст аст.', }, PARSE_INVALID_TYPE: { en: p => (0, text_1.text)(p.detail), ru: () => 'Тип записан неправильно.', tj: () => 'Навъ нодуруст навишта шудааст.', }, PARSE_INVALID_IMPORT_EXPORT: { en: p => (0, text_1.text)(p.detail), ru: () => `${(0, text_1.code)('ворид')} или ${(0, text_1.code)('содир')} записан неправильно.`, tj: () => `${(0, text_1.code)('ворид')} ё ${(0, text_1.code)('содир')} нодуруст навишта шудааст.`, }, PARSE_INVALID_CLASS_MEMBER: { en: p => (0, text_1.text)(p.detail), ru: () => 'Член класса записан неправильно.', tj: () => 'Узви синф нодуруст навишта шудааст.', }, PARSE_TOO_DEEP: { en: () => 'The program nests too deeply to be read.', ru: () => 'Программа слишком глубоко вложена: её нельзя прочитать.', tj: () => 'Қисмҳои барнома аз ҳад зиёд дар дохили якдигар ҷойгир шудаанд.', }, PARSE_INVALID_SYNTAX: { en: p => (0, text_1.text)(p.detail), ru: () => 'Здесь ошибка в записи программы.', tj: () => 'Дар ин ҷо барнома нодуруст навишта шудааст.', }, LEX_UNTERMINATED_STRING: { en: p => `Missing closing quote ${(0, text_1.code)(p.quote)}: the string that starts here is not closed.`, ru: p => `Не хватает закрывающей кавычки ${(0, text_1.code)(p.quote)}: строка, которая начинается здесь, не закрыта.`, tj: p => `Нохунаки пӯшандаи ${(0, text_1.code)(p.quote)} намерасад: матне, ки дар ин ҷо оғоз шуд, баста нашудааст.`, }, LEX_UNTERMINATED_TEMPLATE: { en: () => 'The template string that starts here is not closed with a backtick («`»).', ru: () => 'Шаблонная строка, которая начинается здесь, не закрыта обратной кавычкой «`».', tj: () => 'Қолаби матнӣ, ки дар ин ҷо оғоз шуд, бо нохунаки «`» баста нашудааст.', }, LEX_UNTERMINATED_COMMENT: { en: () => `The comment ${(0, text_1.code)('/*')} is not closed with ${(0, text_1.code)('*/')}.`, ru: () => `Комментарий ${(0, text_1.code)('/*')} не закрыт символами ${(0, text_1.code)('*/')}.`, tj: () => `Шарҳи ${(0, text_1.code)('/*')} бо ${(0, text_1.code)('*/')} баста нашудааст.`, }, LEX_INVALID_NUMBER: { en: p => `Invalid number: ${(0, text_1.text)(p.reason)}.`, ru: () => 'Число записано неправильно.', tj: () => 'Рақам нодуруст навишта шудааст.', }, LEX_INVALID_ESCAPE: { en: () => `Invalid escape sequence after ${(0, text_1.code)('\\')} in a string.`, ru: () => `После ${(0, text_1.code)('\\')} в строке стоит недопустимый символ.`, tj: () => `Пас аз ${(0, text_1.code)('\\')} дар матн аломати нодуруст омадааст.`, }, LEX_UNEXPECTED_CHARACTER: { en: p => `The character ${(0, text_1.code)(p.character)} cannot be used here.`, ru: p => `Символ ${(0, text_1.code)(p.character)} здесь использовать нельзя.`, tj: p => `Аломати ${(0, text_1.code)(p.character)}-ро дар ин ҷо истифода бурдан мумкин нест.`, }, LEX_INVALID_REGEXP: { en: p => `Invalid regular expression: ${(0, text_1.text)(p.detail)}.`, ru: () => 'Регулярное выражение записано неправильно.', tj: () => 'Ифодаи муқаррарӣ нодуруст навишта шудааст.', }, }; }, {"./text":"diagnostics/text.js"}, ], "diagnostics/catalog-types.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TYPE_MESSAGES = void 0; /** * Messages of the type checker. The English text of each entry is the one the * checker has always reported (`compile()` without a language returns it * unchanged); the Russian and Tajik ones are written for learners. Types are * named as SomonScript writes them (`рақам`, `сатр[]`), members by the name * the program uses (`дарозӣ`, not `length`). */ const text_1 = require("./text"); /** `'дарозӣ'` or `'дарозӣ' (length)`: a member and, when it differs, its JavaScript name. */ function shownMember(p) { return p.jsName === undefined || p.jsName === p.name ? `'${(0, text_1.text)(p.name)}'` : `'${(0, text_1.text)(p.name)}' (${(0, text_1.text)(p.jsName)})`; } /** `Қимати "панҷ"` for a literal type, `Навъи сатр` for another type. */ function valueOrType(type, words) { return `${(0, text_1.isLiteralType)(type) ? words.value : words.type} ${(0, text_1.code)((0, text_1.tajikType)(type))}`; } /** The number of arguments a function takes: `2`, `1-2`, `at least 1`. */ function expectedCount(p, words) { if (p.max === undefined) return words.atLeast.replace('{0}', (0, text_1.text)(p.min)); if (p.min === p.max) return (0, text_1.text)(p.min); return words.range.replace('{0}', (0, text_1.text)(p.min)).replace('{1}', (0, text_1.text)(p.max)); } /** The function a call names, or nothing for an anonymous one. */ function functionName(p) { return p.function === undefined ? '' : ` ${(0, text_1.code)(p.function)}`; } exports.TYPE_MESSAGES = { TYPE_NOT_ASSIGNABLE: { en: p => `Type '${(0, text_1.text)(p.source)}' is not assignable to type '${(0, text_1.text)(p.target)}'`, ru: p => `${valueOrType(p.source, { value: 'Значение', type: 'Тип' })} не подходит к типу ${(0, text_1.code)((0, text_1.tajikType)(p.target))}.`, tj: p => `${valueOrType(p.source, { value: 'Қимати', type: 'Навъи' })} ба навъи ${(0, text_1.code)((0, text_1.tajikType)(p.target))} мувофиқ нест.`, }, 'TYPE_NOT_ASSIGNABLE.return': { en: p => `Type '${(0, text_1.text)(p.source)}' is not assignable to return type '${(0, text_1.text)(p.target)}'`, ru: p => `Функция должна возвращать ${(0, text_1.code)((0, text_1.tajikType)(p.target))}, а возвращает ${(0, text_1.code)((0, text_1.tajikType)(p.source))}.`, tj: p => `Функсия бояд қимати навъи ${(0, text_1.code)((0, text_1.tajikType)(p.target))} баргардонад, вале ${(0, text_1.code)((0, text_1.tajikType)(p.source))} бармегардонад.`, }, 'TYPE_NOT_ASSIGNABLE.property': { en: p => `Type '${(0, text_1.text)(p.source)}' is not assignable to type '${(0, text_1.text)(p.target)}' for property '${(0, text_1.text)(p.property)}'`, ru: p => `Свойство ${(0, text_1.code)(p.property)}: ${valueOrType(p.source, { value: 'значение', type: 'тип' })} не подходит к типу ${(0, text_1.code)((0, text_1.tajikType)(p.target))}.`, tj: p => `Хосияти ${(0, text_1.code)(p.property)}: ${valueOrType(p.source, { value: 'қимати', type: 'навъи' })} ба навъи ${(0, text_1.code)((0, text_1.tajikType)(p.target))} мувофиқ нест.`, }, 'TYPE_NOT_ASSIGNABLE.excessProperty': { en: p => `Object literal may only specify known properties, and '${(0, text_1.text)(p.property)}' does not exist in type '${(0, text_1.text)(p.target)}'`, ru: p => `В типе ${(0, text_1.code)((0, text_1.tajikType)(p.target))} нет свойства ${(0, text_1.code)(p.property)}.`, tj: p => `Дар навъи ${(0, text_1.code)((0, text_1.tajikType)(p.target))} хосияти ${(0, text_1.code)(p.property)} нест.`, }, 'TYPE_NOT_ASSIGNABLE.conversion': { en: p => `Conversion of type '${(0, text_1.text)(p.source)}' to type '${(0, text_1.text)(p.target)}' may be a mistake because neither type sufficiently overlaps with the other; assert to 'ношинос' first if this is intended`, ru: p => `Преобразование типа ${(0, text_1.code)((0, text_1.tajikType)(p.source))} в ${(0, text_1.code)((0, text_1.tajikType)(p.target))}, вероятно, ошибка: эти типы почти не совместимы. Если это сделано намеренно, сначала приведите значение к ${(0, text_1.code)('ношинос')}.`, tj: p => `Табдили навъи ${(0, text_1.code)((0, text_1.tajikType)(p.source))} ба ${(0, text_1.code)((0, text_1.tajikType)(p.target))} шояд хато бошад: ин навъҳо қариб мувофиқ нестанд. Агар ин қасдан бошад, аввал ба ${(0, text_1.code)('ношинос')} табдил диҳед.`, }, 'TYPE_NOT_ASSIGNABLE.constAssertion': { en: () => `A 'чун собит' assertion can only be applied to string, number, boolean, array or object literals`, ru: () => `${(0, text_1.code)('чун собит')} можно применять только к строке, числу, логическому значению, массиву или объекту, записанным прямо в коде.`, tj: () => `${(0, text_1.code)('чун собит')}-ро танҳо ба сатр, рақам, қимати мантиқӣ, рӯйхат ё объекте, ки дар худи код навишта шудааст, истифода бурдан мумкин аст.`, }, 'TYPE_NOT_ASSIGNABLE.satisfies': { en: p => `Type '${(0, text_1.text)(p.source)}' does not satisfy the expected type '${(0, text_1.text)(p.expected)}'`, ru: p => `Тип ${(0, text_1.code)((0, text_1.tajikType)(p.source))} не соответствует ожидаемому типу ${(0, text_1.code)((0, text_1.tajikType)(p.expected))}.`, tj: p => `Навъи ${(0, text_1.code)((0, text_1.tajikType)(p.source))} ба навъи интизоршудаи ${(0, text_1.code)((0, text_1.tajikType)(p.expected))} мувофиқ нест.`, }, UNDEFINED_IDENTIFIER: { en: p => `Variable '${(0, text_1.text)(p.name)}' is not defined`, ru: p => `Имя ${(0, text_1.code)(p.name)} не объявлено.`, tj: p => `Номи ${(0, text_1.code)(p.name)} эълон нашудааст.`, }, 'UNDEFINED_IDENTIFIER.parameter': { en: p => `Cannot find parameter '${(0, text_1.text)(p.name)}'`, ru: p => `Параметр ${(0, text_1.code)(p.name)} не найден.`, tj: p => `Параметри ${(0, text_1.code)(p.name)} ёфт нашуд.`, }, PROPERTY_NOT_FOUND: { en: p => `Property ${shownMember(p)} does not exist on type '${(0, text_1.text)(p.type)}'${p.mapSet ? `; use 'дорадКалид' (has) to test membership` : ''}`, ru: p => `В типе ${(0, text_1.code)((0, text_1.tajikType)(p.type))} нет свойства ${(0, text_1.code)(p.name)}.`, tj: p => `Дар навъи ${(0, text_1.code)((0, text_1.tajikType)(p.type))} хосияти ${(0, text_1.code)(p.name)} нест.`, }, 'PROPERTY_NOT_FOUND.static': { en: p => `Property ${shownMember(p)} does not exist on class '${(0, text_1.text)(p.class)}'`, ru: p => `В классе ${(0, text_1.code)(p.class)} нет статического свойства ${(0, text_1.code)(p.name)}.`, tj: p => `Дар синфи ${(0, text_1.code)(p.class)} хосияти статикии ${(0, text_1.code)(p.name)} нест.`, }, 'PROPERTY_NOT_FOUND.builtinObject': { en: p => `Property ${shownMember(p)} does not exist on '${(0, text_1.text)(p.object)}'`, ru: p => `У ${(0, text_1.code)(p.object)} нет свойства ${(0, text_1.code)(p.name)}.`, tj: p => `${(0, text_1.code)(p.object)} хосияти ${(0, text_1.code)(p.name)} надорад.`, }, 'PROPERTY_NOT_FOUND.noDefaultExport': { en: p => `Module '"${(0, text_1.text)(p.module)}"' has no default export`, ru: p => `У модуля ${(0, text_1.code)(p.module)} нет экспорта по умолчанию (${(0, text_1.code)('пешфарз')}).`, tj: p => `Модули ${(0, text_1.code)(p.module)} содироти пешфарз (${(0, text_1.code)('пешфарз')}) надорад.`, }, 'PROPERTY_NOT_FOUND.noExportedMember': { en: p => `Module '"${(0, text_1.text)(p.module)}"' has no exported member '${(0, text_1.text)(p.name)}'`, ru: p => `Модуль ${(0, text_1.code)(p.module)} не экспортирует ${(0, text_1.code)(p.name)}.`, tj: p => `Модули ${(0, text_1.code)(p.module)} ${(0, text_1.code)(p.name)}-ро содир намекунад.`, }, ARGUMENT_COUNT_MISMATCH: { en: p => `Function '${(0, text_1.text)(p.function ?? 'anonymous')}' expected ${expectedCount(p, { range: '{0}-{1}', atLeast: 'at least {0}' })} argument(s) but got ${(0, text_1.text)(p.got)}`, ru: p => `Функция${functionName(p)} принимает аргументов: ${expectedCount(p, { range: 'от {0} до {1}', atLeast: 'не менее {0}' })}, а передано: ${(0, text_1.text)(p.got)}.`, tj: p => `Функсия${functionName(p)} ${expectedCount(p, { range: 'аз {0} то {1}', atLeast: 'ақаллан {0}' })} аргумент мегирад, вале ${(0, text_1.text)(p.got)} аргумент дода шуд.`, }, ARGUMENT_TYPE_MISMATCH: { en: p => `Argument ${(0, text_1.text)(p.index)} of '${(0, text_1.text)(p.function ?? 'anonymous')}' expected type '${(0, text_1.text)(p.expected)}' but got '${(0, text_1.text)(p.got)}'`, ru: p => `Аргумент ${(0, text_1.text)(p.index)} функции${functionName(p)} должен иметь тип ${(0, text_1.code)((0, text_1.tajikType)(p.expected))}, а передано ${(0, text_1.code)((0, text_1.tajikType)(p.got))}.`, tj: p => `Аргументи ${(0, text_1.text)(p.index)}-уми функсия${functionName(p)} бояд навъи ${(0, text_1.code)((0, text_1.tajikType)(p.expected))} дошта бошад, вале ${(0, text_1.code)((0, text_1.tajikType)(p.got))} дода шуд.`, }, POSSIBLY_NULL: { en: p => `${p.reference === undefined ? 'Object' : `'${(0, text_1.text)(p.reference)}'`} is possibly ${p.values.map(value => `'${value}'`).join(' or ')}`, ru: p => `${p.reference === undefined ? 'Значение' : (0, text_1.code)(p.reference)} может быть ${(0, text_1.codes)(p.values, 'ru')}: сначала проверьте это.`, tj: p => `${p.reference === undefined ? 'Қимат' : (0, text_1.code)(p.reference)} шояд ${(0, text_1.codes)(p.values, 'tj')} бошад: аввал инро санҷед.`, }, READONLY_ASSIGNMENT: { en: p => `Cannot assign to '${(0, text_1.text)(p.name)}' because it is a read-only property`, ru: p => `Свойству ${(0, text_1.code)(p.name)} нельзя присвоить значение: оно только для чтения.`, tj: p => `Ба хосияти ${(0, text_1.code)(p.name)} қимат додан мумкин нест: он танҳо барои хондан аст.`, }, 'READONLY_ASSIGNMENT.element': { en: p => `Cannot assign to an element of ${p.reference === undefined ? 'Object' : `'${(0, text_1.text)(p.reference)}'`}: '${(0, text_1.text)(p.type)}' is read-only`, ru: p => `Элементам ${p.reference === undefined ? 'этого массива' : (0, text_1.code)(p.reference)} нельзя присваивать значения: тип ${(0, text_1.code)((0, text_1.tajikType)(p.type))} только для чтения.`, tj: p => `Ба унсурҳои ${p.reference === undefined ? 'ин рӯйхат' : (0, text_1.code)(p.reference)} қимат додан мумкин нест: навъи ${(0, text_1.code)((0, text_1.tajikType)(p.type))} танҳо барои хондан аст.`, }, USED_BEFORE_INITIALIZATION: { en: p => `Property '${(0, text_1.text)(p.name)}' is used before its initialization: field initializers run before the constructor assigns parameter properties`, ru: p => `Свойство ${(0, text_1.code)(p.name)} используется до того, как получило значение: начальные значения полей вычисляются раньше конструктора.`, tj: p => `Хосияти ${(0, text_1.code)(p.name)} пеш аз гирифтани қимат истифода шудааст: қиматҳои ибтидоии майдонҳо пеш аз конструктор ҳисоб мешаванд.`, }, NO_MATCHING_OVERLOAD: { en: p => `No overload of '${(0, text_1.text)(p.function ?? 'anonymous')}' matches this call. Overloads: ${(0, text_1.text)(p.overloads)}`, ru: p => `Ни один вариант функции${functionName(p)} не подходит к этому вызову. Варианты: ${(0, text_1.tajikType)(p.overloads)}`, tj: p => `Ҳеҷ як варианти функсия${functionName(p)} ба ин даъват мувофиқ нест. Вариантҳо: ${(0, text_1.tajikType)(p.overloads)}`, }, 'INVALID_OVERRIDE.noBase': { en: p => `This member cannot have an 'бознавис' (override) modifier because its containing class '${(0, text_1.text)(p.class)}' does not extend another class`, ru: p => `Здесь нельзя писать ${(0, text_1.code)('бознавис')}: класс ${(0, text_1.code)(p.class)} не наследует другой класс.`, tj: p => `Дар ин ҷо ${(0, text_1.code)('бознавис')} навиштан мумкин нест: синфи ${(0, text_1.code)(p.class)} аз синфи дигар мерос намегирад.`, }, 'INVALID_OVERRIDE.notInBase': { en: p => `This member cannot have an 'бознавис' (override) modifier because it is not declared in the base class '${(0, text_1.text)(p.base)}'`, ru: p => `Здесь нельзя писать ${(0, text_1.code)('бознавис')}: в базовом классе ${(0, text_1.code)(p.base)} нет такого члена.`, tj: p => `Дар ин ҷо ${(0, text_1.code)('бознавис')} навиштан мумкин нест: дар синфи асосии ${(0, text_1.code)(p.base)} чунин узв нест.`, }, TYPE_ONLY_IMPORT_VALUE: { en: p => `'${(0, text_1.text)(p.name)}' cannot be used as a value because it was imported using 'ворид навъ'`, ru: p => `${(0, text_1.code)(p.name)} импортирован только как тип (${(0, text_1.code)('ворид навъ')}), его нельзя использовать как значение.`, tj: p => `${(0, text_1.code)(p.name)} танҳо ҳамчун навъ ворид шудааст (${(0, text_1.code)('ворид навъ')}) ва онро ҳамчун қимат истифода бурдан мумкин нест.`, }, ABSTRACT_INSTANTIATION: { en: p => `Cannot create an instance of an abstract class '${(0, text_1.text)(p.class)}'`, ru: p => `Нельзя создать объект абстрактного класса ${(0, text_1.code)(p.class)}.`, tj: p => `Аз синфи мавҳуми ${(0, text_1.code)(p.class)} объект сохтан мумкин нест.`, }, 'CONSTANT_CONDITION.truthy': { en: () => 'This kind of expression is always truthy', ru: () => 'Такое выражение всегда истинно: условие ничего не проверяет.', tj: () => 'Чунин ифода ҳамеша дуруст аст: шарт ҳеҷ чизро намесанҷад.', }, 'CONSTANT_CONDITION.falsy': { en: () => 'This kind of expression is always falsy', ru: () => 'Такое выражение всегда ложно: условие никогда не выполнится.', tj: () => 'Чунин ифода ҳамеша нодуруст аст: шарт ҳеҷ гоҳ иҷро намешавад.', }, 'CONSTANT_CONDITION.neverNullish': { en: () => 'Right operand of ?? is unreachable because the left operand is never nullish', ru: () => `Правая часть ${(0, text_1.code)('??')} никогда не вычисляется: левая часть никогда не бывает ${(0, text_1.code)('холӣ')} или ${(0, text_1.code)('беқимат')}.`, tj: () => `Тарафи рости ${(0, text_1.code)('??')} ҳеҷ гоҳ ҳисоб намешавад: тарафи чап ҳеҷ гоҳ ${(0, text_1.code)('холӣ')} ё ${(0, text_1.code)('беқимат')} намешавад.`, }, 'CONSTANT_CONDITION.alwaysNullish': { en: () => 'This expression is always nullish', ru: () => `Это выражение всегда ${(0, text_1.code)('холӣ')} или ${(0, text_1.code)('беқимат')}.`, tj: () => `Ин ифода ҳамеша ${(0, text_1.code)('холӣ')} ё ${(0, text_1.code)('беқимат')} аст.`, }, TYPE_NOT_FOUND: { en: p => `Cannot find type '${(0, text_1.text)(p.name)}'`, ru: p => `Тип ${(0, text_1.code)(p.name)} не найден.`, tj: p => `Навъи ${(0, text_1.code)(p.name)} ёфт нашуд.`, }, CLASS_NOT_FOUND: { en: p => `Base class '${(0, text_1.text)(p.name)}' not found`, ru: p => `Базовый класс ${(0, text_1.code)(p.name)} не найден.`, tj: p => `Синфи асосии ${(0, text_1.code)(p.name)} ёфт нашуд.`, }, INVALID_EXTENDS: { en: p => `Class '${(0, text_1.text)(p.class)}' can only extend other classes, but '${(0, text_1.text)(p.parent)}' is ${p.kind === 'interface' ? 'an interface' : `a ${(0, text_1.text)(p.kind)}`}`, ru: p => `Класс ${(0, text_1.code)(p.class)} может наследовать только другой класс, а ${(0, text_1.code)(p.parent)} - ${p.kind === 'interface' ? 'интерфейс' : 'не класс'}.`, tj: p => `Синфи ${(0, text_1.code)(p.class)} танҳо аз синфи дигар мерос гирифта метавонад, вале ${(0, text_1.code)(p.parent)} ${p.kind === 'interface' ? 'интерфейс' : 'синф нест'}.`, }, CIRCULAR_INHERITANCE: { en: p => `Circular inheritance detected involving class '${(0, text_1.text)(p.class)}'`, ru: p => `Классы наследуют друг друга по кругу (в том числе ${(0, text_1.code)(p.class)}).`, tj: p => `Синфҳо даврвор аз ҳамдигар мерос мегиранд (аз ҷумла ${(0, text_1.code)(p.class)}).`, }, 'CIRCULAR_INHERITANCE.self': { en: p => `Circular inheritance detected: class '${(0, text_1.text)(p.class)}' cannot extend itself`, ru: p => `Класс ${(0, text_1.code)(p.class)} не может наследовать сам себя.`, tj: p => `Синфи ${(0, text_1.code)(p.class)} аз худаш мерос гирифта наметавонад.`, }, NOT_CALLABLE: { en: p => `'${(0, text_1.text)(p.name)}' is not a function and cannot be called`, ru: p => `${(0, text_1.code)(p.name)} - не функция, его нельзя вызвать.`, tj: p => `${(0, text_1.code)(p.name)} функсия нест ва онро даъват кардан мумкин нест.`, }, CONST_ASSIGNMENT: { en: p => `Cannot assign to '${(0, text_1.text)(p.name)}' because it is a constant`, ru: p => `Нельзя присвоить новое значение ${(0, text_1.code)(p.name)}: оно объявлено через ${(0, text_1.code)('собит')}.`, tj: p => `Ба ${(0, text_1.code)(p.name)} қимати нав додан мумкин нест, зеро он бо ${(0, text_1.code)('собит')} эълон шудааст.`, }, ASSIGNMENT_IN_CONDITION: { en: () => `The condition assigns a value with '=': to compare values, write '===' or '=='`, ru: () => `В условии ${(0, text_1.code)('=')} присваивает значение. Чтобы сравнить значения, пишите ${(0, text_1.code)('===')} или ${(0, text_1.code)('==')}.`, tj: () => `Дар шарт ${(0, text_1.code)('=')} қимат медиҳад. Барои муқоисаи қиматҳо ${(0, text_1.code)('===')} ё ${(0, text_1.code)('==')} нависед.`, }, }; }, {"./text":"diagnostics/text.js"}, ], "diagnostics/catalog.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.HINT_IDS = exports.MESSAGE_IDS = void 0; exports.codeOf = codeOf; exports.message = message; exports.renderMessage = renderMessage; exports.renderHint = renderHint; /** * The catalog of diagnostics: every message the compiler reports, by id, in * English, Russian and Tajik (docs/glossary.tj.md lists the Tajik terms). */ const catalog_learner_1 = require("./catalog-learner"); const catalog_program_1 = require("./catalog-program"); const catalog_runtime_1 = require("./catalog-runtime"); const catalog_syntax_1 = require("./catalog-syntax"); const catalog_types_1 = require("./catalog-types"); const MESSAGES = { ...catalog_syntax_1.SYNTAX_MESSAGES, ...catalog_types_1.TYPE_MESSAGES, ...catalog_program_1.PROGRAM_MESSAGES, ...catalog_runtime_1.RUNTIME_MESSAGES, ...catalog_learner_1.LEARNER_MESSAGES, }; const ALL_HINTS = { ...catalog_program_1.HINTS, ...catalog_runtime_1.RUNTIME_HINTS }; /** Every message id of the catalog (hints apart). */ exports.MESSAGE_IDS = Object.keys(MESSAGES); /** Every hint id. */ exports.HINT_IDS = Object.keys(ALL_HINTS); /** The diagnostic code of a message id: `TYPE_NOT_ASSIGNABLE.return` → `TYPE_NOT_ASSIGNABLE`. */ function codeOf(id) { const dot = id.indexOf('.'); return dot === -1 ? id : id.slice(0, dot); } /** A message of the catalog with its values: `message('UNDEFINED_IDENTIFIER', { name })`. */ function message(id, params = {}) { return { id, params }; } /** The text of a message in a language. Throws for an id the catalog does not have. */ function renderMessage(msg, language) { return entry(MESSAGES, msg.id)[language](msg.params); } /** The text of a hint in a language. */ function renderHint(hint, language) { return entry(ALL_HINTS, hint.id)[language](hint.params); } function entry(table, id) { const found = table[id]; if (!found) throw new Error(`Unknown diagnostic '${id}'`); return found; } }, {"./catalog-learner":"diagnostics/catalog-learner.js","./catalog-program":"diagnostics/catalog-program.js","./catalog-runtime":"diagnostics/catalog-runtime.js","./catalog-syntax":"diagnostics/catalog-syntax.js","./catalog-types":"diagnostics/catalog-types.js"}, ], "diagnostics/classify.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.classifySyntaxError = classifySyntaxError; exports.classifyCodegenError = classifyCodegenError; /** * What the lexer's, the parser's and the code generator's errors are about. * Those stages report English sentences of a few stable shapes ("Unexpected * token ';' at line 1, column 6 (Expected ')' after arguments)"); this module * reads them into a catalog message with its values, finds where a missing * bracket was opened, and adds a hint ("Did you mean `агар`?"). The sentences * themselves stay what `compile()` returns when no language is asked for. */ const catalog_1 = require("./catalog"); const suggest_1 = require("./suggest"); const lexer_1 = require("../lexer"); const tokens_1 = require("../tokens"); const POSITION = /at line (\d+), column (\d+)/; const UNEXPECTED_TOKEN = /^Unexpected token (end of input|'(.*)') at line (\d+), column (\d+)(?: $([\s\S]*)$)?$/; /** Each closing bracket and the opening one it closes. */ const CLOSING = { '}': '{', ')': '(', ']': '[', '>': '<' }; const OPENING = new Set(['{', '(', '[']); /** Brackets as tokens; `<` and `>` are also comparisons, so type arguments are not matched. */ const BRACKETS = new Set([ tokens_1.TokenType.LEFT_BRACE, tokens_1.TokenType.RIGHT_BRACE, tokens_1.TokenType.LEFT_PAREN, tokens_1.TokenType.RIGHT_PAREN, tokens_1.TokenType.LEFT_BRACKET, tokens_1.TokenType.RIGHT_BRACKET, ]); /** Examples of conditions in parentheses, for `агар х > 0 {`. */ const CONDITION_EXAMPLES = { агар: 'агар (х > 0) { … }', то: 'то (х < 10) { … }', барои: 'барои (тағ и = 0; и < 5; и++) { … }', интихоб: 'интихоб (х) { … }', }; /** The line and column an error message names. */ function positionOf(raw) { const match = POSITION.exec(raw); return match ? { line: Number(match[1]), column: Number(match[2]) } : {}; } /** The message with its position left out: the detail of a message kept in English. */ function detailOf(raw) { return raw.replace(/ at line \d+(?:, column \d+)?/, ''); } /** Lexer and parser errors. */ function classifySyntaxError(raw, source) { const unexpected = UNEXPECTED_TOKEN.exec(raw); if (unexpected) { const found = unexpected[1] === 'end of input' ? undefined : unexpected[2]; const position = { line: Number(unexpected[3]), column: Number(unexpected[4]) }; const context = new SourceContext(source); const result = unexpected[5] === undefined ? classifyBareToken(found, position, context) : classifyExpectation(unexpected[5], found, position, context); return context.finish(result, found); } const result = classifyLexerError(raw, source) ?? classifyStandalone(raw, source); result.hint ?? (result.hint = tripleQuoteHint(source.split(/\r?\n/), result.line, result.column)); return result; } /** * Python's `"""` or `'''` on the line of an error, up to it: SomonScript reads * them as an empty string and a quote, and a learner who wrote text of several * lines in them is told what to write instead. */ function tripleQuoteHint(lines, line, column) { if (line === undefined || column === undefined) return undefined; const quotes = /"""|'''/.exec(lines[line - 1]?.slice(0, column) ?? ''); return quotes ? (0, catalog_1.message)('TRIPLE_QUOTES', { quotes: quotes[0] }) : undefined; } /** Code generator errors: names declared twice, `шикастан` outside a loop, … */ function classifyCodegenError(raw) { const position = positionOf(raw); const of = (id, params = {}, hint) => ({ message: (0, catalog_1.message)(id, params), ...position, hint, }); const redeclared = /^Identifier '([^']+)' has already been declared/.exec(raw); if (redeclared) { const name = redeclared[1]; return of('CODEGEN_REDECLARED', { name }, name.startsWith('#') ? undefined : (0, catalog_1.message)('NO_REDECLARE', { name })); } const reserved = /^'([^']+)' is a reserved word in JavaScript and cannot be used as an identifier/.exec(raw); if (reserved) return of('CODEGEN_RESERVED_WORD', { name: reserved[1] }, (0, catalog_1.message)('RENAME')); if (raw.startsWith('Illegal break statement')) return of('CODEGEN_OUTSIDE_LOOP.break'); if (/^Illegal continue statement.*'давом' must be inside a loop/.test(raw)) { return of('CODEGEN_OUTSIDE_LOOP.continue'); } if (/'барои интизор' must be inside|'интизор истифода' is only allowed|^Top-level 'интизор'/.test(raw)) { return of('CODEGEN_AWAIT_OUTSIDE_ASYNC'); } const label = /[Ll]abel '([^']+)'|^Illegal continue statement.*: '([^']+)' does not label/.exec(raw); if (label) return of('CODEGEN_INVALID_LABEL', { name: label[1] ?? label[2], detail: detailOf(raw) }); return of('CODEGEN_INVALID', { detail: detailOf(raw) }); } function classifyLexerError(raw, source) { const position = positionOf(raw); const of = (id, params = {}) => ({ message: (0, catalog_1.message)(id, params), ...position, }); if (raw.startsWith('Unterminated string')) { // The lexer names the position of the opening quote const line = source.split(/\r?\n/)[position.line - 1]; const quote = line[position.column - 1] === "'" ? "'" : '"'; return of('LEX_UNTERMINATED_STRING', { quote }); } if (raw.startsWith('Unterminated template literal')) return of('LEX_UNTERMINATED_TEMPLATE'); if (raw.startsWith('Unterminated block comment')) return of('LEX_UNTERMINATED_COMMENT'); const number = /^Invalid number format at line \d+, column \d+: (.*)$/.exec(raw); if (number) return of('LEX_INVALID_NUMBER', { reason: number[1] }); if (raw.startsWith('Invalid escape sequence')) return of('LEX_INVALID_ESCAPE'); const character = /^Unexpected character '(.*)' at line/.exec(raw); if (character) return of('LEX_UNEXPECTED_CHARACTER', { character: character[1] }); if (raw.startsWith('Unterminated regular expression')) { return of('PARSE_EXPECTED_EXPRESSION', { found: '/' }); } if (/^Invalid regular expression/.test(raw)) return of('LEX_INVALID_REGEXP', { detail: detailOf(raw) }); return undefined; } /** Parser errors that are not about an unexpected token, by what they say. */ const STANDALONE = [ { test: /^Invalid shorthand property initializer/, id: 'PARSE_SHORTHAND_INITIALIZER' }, { test: /^Multiple default cases in switch/, id: 'PARSE_DUPLICATE_DEFAULT_CASE' }, { test: /^Nesting too deep/, id: 'PARSE_TOO_DEEP' }, { test: /^'([^']+)' modifier|^'(танҳохонӣ)' can only be used/, id: 'PARSE_INVALID_MODIFIER', modifier: true, }, { test: /accessor|^Getter |^Setter |private field named|^An accessibility modifier|parameter property|^A decorator can only/, id: 'PARSE_INVALID_CLASS_MEMBER', }, { test: /conditional type|type modifier|tuple element|^Tuple members|type parameter|^Catch clause variable type|index signature/, id: 'PARSE_INVALID_TYPE', }, { test: /import|export|local name/i, id: 'PARSE_INVALID_IMPORT_EXPORT' }, { test: /ambient contexts|binding patterns|^Function implementation is missing|^A declaration cannot be labeled|in enums|property name|^Decorators are not valid/, id: 'PARSE_INVALID_DECLARATION', }, ]; function classifyStandalone(raw, source) { const position = positionOf(raw); // `Expected '}' after class body at line …`: as the same message after an unexpected token const expected = /^(Expected [\s\S]*?) at line \d+(?:, column \d+)?$/.exec(raw); if (expected && position.line !== undefined) { const context = new SourceContext(source); const found = context.tokenAt(position)?.value; return context.finish(classifyExpectation(expected[1], found, position, context), found); } const switchToken = /^Unexpected token '(.*)' in switch/.exec(raw); if (switchToken) return { message: (0, catalog_1.message)('PARSE_UNEXPECTED_TOKEN', { found: switchToken[1] }), ...position }; const rule = STANDALONE.find(candidate => candidate.test.test(raw)); if (rule?.modifier) { const match = rule.test.exec(raw); const modifier = match[1] ?? match[2]; return { message: (0, catalog_1.message)(rule.id, { modifier, detail: detailOf(raw) }), ...position }; } return { message: (0, catalog_1.message)(rule?.id ?? 'PARSE_INVALID_SYNTAX', { detail: detailOf(raw) }), ...position, }; } /** `Unexpected token X at …` with nothing expected: a stray closing bracket, or a missing operand. */ function classifyBareToken(found, position, context) { if (found !== undefined && found !== '>' && found in CLOSING && !context.openerFor(found, position, true)) { return { message: (0, catalog_1.message)('PARSE_UNMATCHED_CLOSE', { close: found }), ...position }; } return { message: (0, catalog_1.message)('PARSE_EXPECTED_EXPRESSION', { found }), ...position }; } /** Names the parser expects, by the words of its message. */ const EXPECTED_NAMES = [ [/^variable name/, 'variable'], [/^property name/, 'property'], [/^enum member name/, 'enumMember'], [/^namespace name/, 'namespace'], [/^(a )?module path/, 'module'], [/^superclass name/, 'class'], [/^decorator name/, 'decorator'], [/^type( name)?$|^type name /, 'type'], [/^a declaration/, 'declaration'], [/^identifier/, 'identifier'], ]; /** `Expected …` messages: what the parser expected where it found `found`. */ function classifyExpectation(inner, found, position, context) { const token = /^Expected '([^']+)'(?: or '([^']+)')?(?: (?:after|before|in|to) ([\s\S]*))?$/.exec(inner); if (token) { const expectation = { expected: token[1], alternative: token[2], context: token[3] ?? '' }; return classifyExpectedToken(expectation, found, position, context); } const name = /^Expected ([\s\S]*)$/.exec(inner); const what = name ? EXPECTED_NAMES.find(([pattern]) => pattern.test(name[1]))?.[1] : undefined; if (what) return { message: (0, catalog_1.message)('PARSE_EXPECTED_NAME', { what, found }), ...position }; const id = /index signature/.test(inner) ? 'PARSE_INVALID_TYPE' : 'PARSE_INVALID_SYNTAX'; return { message: (0, catalog_1.message)(id, { detail: inner }), ...position }; } function classifyExpectedToken({ expected, alternative, context: contextText }, found, position, context) { const at = { ...position }; if (alternative === undefined && expected in CLOSING) { const opener = context.openerFor(expected, position, false); const result = { message: (0, catalog_1.message)('PARSE_MISSING_CLOSE', { close: expected, open: CLOSING[expected], found, openLine: opener?.line, }), ...at, related: opener, }; if (expected === ')' && found === ';' && context.closesLaterOnLine(position, ')')) { result.hint = (0, catalog_1.message)('ARGUMENT_COMMA'); } return result; } const keyword = /^'([^']+)'/.exec(contextText)?.[1]; if (expected === '(' && keyword !== undefined && keyword in CONDITION_EXAMPLES) { return { message: (0, catalog_1.message)('PARSE_CONDITION_PARENS', { keyword, example: CONDITION_EXAMPLES[keyword] }), ...at, }; } if (alternative === undefined && OPENING.has(expected)) { return { message: (0, catalog_1.message)('PARSE_EXPECTED_OPEN', { open: expected, after: keyword }), ...at }; } if (alternative === undefined && expected === ';') { const hint = context.insideForHead(position) ? (0, catalog_1.message)('FOR_SEMICOLONS') : undefined; return { message: (0, catalog_1.message)('PARSE_EXPECTED_SEMICOLON', { found }), ...at, hint }; } const expectedTokens = alternative === undefined ? expected : [expected, alternative]; return { message: (0, catalog_1.message)('PARSE_EXPECTED_TOKEN', { expected: expectedTokens, found }), ...at }; } /** The tokens of the source (as far as the lexer reads it) and questions about them. */ class SourceContext { constructor(source) { this.source = source; this.lines = source.split(/\r?\n/); try { this.tokens = new lexer_1.Lexer(source).tokenize(); } catch { // The parser ran, so the lexer did too; a source given separately may not lex this.tokens = []; } } tokenAt(position) { return this.tokens.find(token => token.line === position.line && token.column === position.column && token.type !== tokens_1.TokenType.EOF); } /** * The innermost bracket before `position` (or at it, with `including`) that * `close` would close and nothing closed yet. */ openerFor(close, position, including) { const open = CLOSING[close]; const stack = []; for (const token of this.tokens) { const after = token.line > position.line || (token.line === position.line && token.column > position.column); const at = token.line === position.line && token.column === position.column; if (after || (at && !including)) break; if (!BRACKETS.has(token.type)) continue; if (OPENING.has(token.value)) { stack.push(token); } else if (stack.length > 0 && stack[stack.length - 1].value === CLOSING[token.value]) { if (at) return stack[stack.length - 1]; stack.pop(); } } for (let index = stack.length - 1; index >= 0; index--) { if (stack[index].value === open) return stack[index]; } return undefined; } /** Whether a `close` comes later on the line of `position`: `чоп(1; 2)`. */ closesLaterOnLine(position, close) { return this.tokens.some(token => token.line === position.line && token.column > position.column && token.value === close); } /** Whether `position` is inside the parentheses of a `барои (…)`. */ insideForHead(position) { const opener = this.openerFor(')', position, false); if (!opener) return false; const index = this.tokens.indexOf(opener); return this.tokens[index - 1]?.type === tokens_1.TokenType.БАРОИ; } /** * Completes a classification: a position at the end of the program moves * to the end of its last line, the caret covers the token found, and a * misspelt keyword or an English one gets a hint. */ finish(result, found) { if (found === undefined && result.line !== undefined) Object.assign(result, this.endOfProgram()); else if (found !== undefined) result.length = [...found].length; if (result.message.params.openLine !== undefined || result.message.id === 'PARSE_MISSING_CLOSE') { result.message = (0, catalog_1.message)(result.message.id, { ...result.message.params, line: result.line }); } if (!result.hint && result.line !== undefined) { result.hint = tripleQuoteHint(this.lines, result.line, result.column) ?? this.keywordHint(result.line, result.column); } return result; } /** Just after the last character that is not white space. */ endOfProgram() { for (let index = this.lines.length - 1; index >= 0; index--) { const trimmed = this.lines[index].trimEnd(); if (trimmed !== '') return { line: index + 1, column: trimmed.length + 1 }; } return { line: 1, column: 1 }; } /** * A word on the line of the error, before it, that is no keyword but close * to one (`агр` → `агар`) or an English keyword (`if` → `агар`), unless the * program declares that name. */ keywordHint(line, column) { const words = this.tokens.filter(token => token.type === tokens_1.TokenType.IDENTIFIER && token.line === line && token.column < column && !this.isDeclared(token.value)); for (const word of words) { const tajik = suggest_1.ENGLISH_WORDS.get(word.value); if (tajik) return (0, catalog_1.message)('ENGLISH_KEYWORD', { english: word.value, tajik }); const keyword = (0, suggest_1.closestName)(word.value, suggest_1.STATEMENT_KEYWORDS); if (keyword) return (0, catalog_1.message)('DID_YOU_MEAN', { name: keyword }); } return undefined; } /** Whether the program declares `name` (`тағ ном`, `функсия ном`, a parameter, …). */ isDeclared(name) { return this.tokens.some((token, index) => { if (token.value !== name || index === 0) return false; const before = this.tokens[index - 1]; return ([tokens_1.TokenType.ТАҒЙИРЁБАНДА, tokens_1.TokenType.СОБИТ, tokens_1.TokenType.ФУНКСИЯ, tokens_1.TokenType.СИНФ].includes(before.type) || before.value === '(' || before.value === ','); }); } } }, {"./catalog":"diagnostics/catalog.js","./suggest":"diagnostics/suggest.js","../lexer":"lexer.js","../tokens":"tokens.js"}, ], "diagnostics/format.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.formatDiagnostic = formatDiagnostic; exports.formatDiagnosticLine = formatDiagnosticLine; exports.formatFailure = formatFailure; /** * Diagnostics as a learner reads them: where (file and line), what, the line * of code with a caret under the place, and a hint. * * Хато дар барнома.som, сатри 3: * Қавси пӯшандаи `}` намерасад. Қавси `{` дар сатри 2 кушода шудааст. * 2 | агар (а > 0) { * | ^ * 3 | чоп(а); * | ^ */ const text_1 = require("./text"); const WORDS = { en: { error: 'Error', warning: 'Warning', runtime: 'Runtime error', where: (severity, file, line) => { if (file !== undefined && line !== undefined) return `${severity} in ${file}, line ${line}`; if (line !== undefined) return `${severity} on line ${line}`; return file === undefined ? severity : `${severity} in ${file}`; }, hint: 'Hint', failed: errors => `The program did not compile: ${errors} ${errors === 1 ? 'error' : 'errors'}.`, }, ru: { error: 'Ошибка', warning: 'Предупреждение', runtime: 'Ошибка выполнения', where: (severity, file, line) => { if (file !== undefined && line !== undefined) return `${severity} в ${file}, строка ${line}`; if (line !== undefined) return `${severity} в строке ${line}`; return file === undefined ? severity : `${severity} в ${file}`; }, hint: 'Подсказка', failed: errors => `Программа не скомпилирована: ${errors} ${(0, text_1.russianPlural)(errors, ['ошибка', 'ошибки', 'ошибок'])}.`, }, tj: { error: 'Хато', warning: 'Огоҳӣ', runtime: 'Хатои иҷро', where: (severity, file, line) => { if (file !== undefined && line !== undefined) return `${severity} дар ${file}, сатри ${line}`; if (line !== undefined) return `${severity} дар сатри ${line}`; return file === undefined ? severity : `${severity} дар ${file}`; }, hint: 'Маслиҳат', failed: errors => `Барнома компайл нашуд: ${errors} хато.`, }, }; /** A diagnostic as a block of lines (no line break at the end). */ function formatDiagnostic(diagnostic, options) { const words = WORDS[options.language]; const lines = [`${header(diagnostic, options)}:`, ` ${diagnostic.message}`]; lines.push(...snippet(diagnostic, options.source)); if (diagnostic.hint) lines.push(` ${words.hint}: ${diagnostic.hint}`); return lines.join('\n'); } /** A diagnostic on one line: `Огоҳӣ дар барнома.som, сатри 2: …`. */ function formatDiagnosticLine(diagnostic, options) { return `${header(diagnostic, options)}: ${diagnostic.message}`; } /** The last line of a failed compilation: `Барнома компайл нашуд: 2 хато.` */ function formatFailure(errors, language) { return WORDS[language].failed(errors); } function header(diagnostic, options) { const words = WORDS[options.language]; const error = options.runtime ? words.runtime : words.error; const severity = diagnostic.severity === 'error' ? error : words.warning; return words.where(severity, options.file ?? diagnostic.file, diagnostic.line); } /** * The line of the diagnostic, and the line of its related place when that is * another one, each with a caret line; nothing without the source or a line. */ function snippet(diagnostic, source) { if (source === undefined || diagnostic.line === undefined) return []; const sourceLines = source.split(/\r?\n/); const places = [ { line: diagnostic.line, column: diagnostic.column ?? 1, length: diagnostic.length }, ]; if (diagnostic.related && diagnostic.related.line !== diagnostic.line) { places.push({ ...diagnostic.related, length: 1 }); } places.sort((a, b) => a.line - b.line); const width = String(places[places.length - 1].line).length; const output = []; for (const place of places) { const code = sourceLines[place.line - 1]; if (code === undefined) continue; const gutter = String(place.line).padStart(width); output.push(` ${gutter} | ${code}`.trimEnd()); output.push(` ${' '.repeat(width)} | ${caret(code, place.column, place.length ?? 1)}`); } return output; } /** Spaces (tabs where the code has them) up to the column, then `^^^`. */ function caret(code, column, length) { const before = code.slice(0, Math.max(column - 1, 0)).replace(/[^\t]/g, ' '); const padding = before.padEnd(Math.max(column - 1, 0), ' '); return `${padding}${'^'.repeat(Math.max(length, 1))}`; } }, {"./text":"diagnostics/text.js"}, ], "diagnostics/index.js": [ function (module, exports, require) { "use strict"; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; var desc = Object.getOwnPropertyDescriptor(m, k); if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { desc = { enumerable: true, get: function() { return m[k]; } }; } Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; })); var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", { value: true }); exports.editDistance = exports.closestName = exports.formatFailure = exports.formatDiagnosticLine = exports.formatDiagnostic = exports.HINT_IDS = exports.MESSAGE_IDS = exports.renderMessage = exports.renderHint = exports.message = exports.codeOf = void 0; exports.classifiedDiagnostic = classifiedDiagnostic; exports.syntaxDiagnostic = syntaxDiagnostic; exports.codegenDiagnostic = codegenDiagnostic; exports.detailDiagnostic = detailDiagnostic; exports.typeDiagnostic = typeDiagnostic; /** * Diagnostics in the learner's language: the compiler's errors and warnings * as `Diagnostic` objects (code, message, place, hint) and as text. */ const catalog_1 = require("./catalog"); const classify_1 = require("./classify"); const suggest_1 = require("./suggest"); const text_1 = require("./text"); var catalog_2 = require("./catalog"); Object.defineProperty(exports, "codeOf", { enumerable: true, get: function () { return catalog_2.codeOf; } }); Object.defineProperty(exports, "message", { enumerable: true, get: function () { return catalog_2.message; } }); Object.defineProperty(exports, "renderHint", { enumerable: true, get: function () { return catalog_2.renderHint; } }); Object.defineProperty(exports, "renderMessage", { enumerable: true, get: function () { return catalog_2.renderMessage; } }); Object.defineProperty(exports, "MESSAGE_IDS", { enumerable: true, get: function () { return catalog_2.MESSAGE_IDS; } }); Object.defineProperty(exports, "HINT_IDS", { enumerable: true, get: function () { return catalog_2.HINT_IDS; } }); var format_1 = require("./format"); Object.defineProperty(exports, "formatDiagnostic", { enumerable: true, get: function () { return format_1.formatDiagnostic; } }); Object.defineProperty(exports, "formatDiagnosticLine", { enumerable: true, get: function () { return format_1.formatDiagnosticLine; } }); Object.defineProperty(exports, "formatFailure", { enumerable: true, get: function () { return format_1.formatFailure; } }); var suggest_2 = require("./suggest"); Object.defineProperty(exports, "closestName", { enumerable: true, get: function () { return suggest_2.closestName; } }); Object.defineProperty(exports, "editDistance", { enumerable: true, get: function () { return suggest_2.editDistance; } }); __exportStar(require("./types"), exports); /** A classified error as a diagnostic in `language`. */ function classifiedDiagnostic(classified, severity, language) { return build(classified.message, severity, language, { line: classified.line, column: classified.column, length: classified.length, related: classified.related && { line: classified.related.line, column: classified.related.column, }, hint: classified.hint, }); } /** A lexer or parser error (the parser's English sentence) as a diagnostic. */ function syntaxDiagnostic(raw, source, language) { return classifiedDiagnostic((0, classify_1.classifySyntaxError)(raw, source), 'error', language); } /** A code generator error as a diagnostic. */ function codegenDiagnostic(raw, source, language) { const classified = (0, classify_1.classifyCodegenError)(raw); // The code generator names the statement; the caret goes under the name it is about const name = classified.message.params.name; const position = name === undefined ? classified : namePosition(source, classified, (0, text_1.text)(name)); return classifiedDiagnostic({ ...classified, ...position, length: (0, text_1.nameLength)(source, position.line, position.column) }, 'error', language); } /** The first `name` on the line of `from`, at or after its column; `from` when there is none. */ function namePosition(source, from, name) { if (from.line === undefined) return from; // The code generator names the line of a statement of the source const line = source.split(/\r?\n/)[from.line - 1]; const index = line.indexOf(name, from.column - 1); return index === -1 ? from : { line: from.line, column: index + 1 }; } /** An error whose text stays as it is (an option, the target, a crash), in the catalog's words. */ function detailDiagnostic(id, detail, language, position = {}) { return build((0, catalog_1.message)(id, { detail }), 'error', language, position); } /** * A type checker error or warning as a diagnostic: the catalog's text for * its message, or, for the TypeScript checker's, its own text (already in * the requested language). */ function typeDiagnostic(error, source, language) { const position = { line: error.line, column: error.column, length: (0, text_1.nameLength)(source, error.line, error.column), }; if (!error.messageId) { return { code: error.code, severity: error.severity, message: error.message, ...position }; } // The checker gives every message of the catalog its values const msg = { id: error.messageId, params: error.params }; return build(msg, error.severity, language, { ...position, hint: typeHint(msg) }); } function build(msg, severity, language, extra) { const { hint, ...place } = extra; const diagnostic = { code: (0, catalog_1.codeOf)(msg.id), severity, message: (0, catalog_1.renderMessage)(msg, language), }; for (const [key, value] of Object.entries(place)) { if (value !== undefined) Object.assign(diagnostic, { [key]: value }); } if (hint) diagnostic.hint = (0, catalog_1.renderHint)(hint, language); return diagnostic; } /** Advice for a type checker message: a name it probably means, or what to do. */ function typeHint(msg) { const p = msg.params; const code = (0, catalog_1.codeOf)(msg.id); const tajik = msg.id === 'UNDEFINED_IDENTIFIER' ? suggest_1.ENGLISH_WORDS.get((0, text_1.text)(p.name)) : undefined; if (tajik) return (0, catalog_1.message)('ENGLISH_KEYWORD', { english: p.name, tajik }); if (p.suggestion !== undefined) return (0, catalog_1.message)('DID_YOU_MEAN', { name: p.suggestion }); if (msg.id === 'UNDEFINED_IDENTIFIER') return (0, catalog_1.message)('DECLARE_FIRST'); if (p.mapSet) return (0, catalog_1.message)('HAS_FOR_MAP_SET'); if (code === 'CONST_ASSIGNMENT') return (0, catalog_1.message)('USE_TAG'); const quotedNumber = /^"(-?\d+(?:\.\d+)?)"$/.exec((0, text_1.text)(p.source)); if (msg.id === 'TYPE_NOT_ASSIGNABLE' && quotedNumber && p.target === 'рақам') { return (0, catalog_1.message)('NUMBER_IN_QUOTES', { value: quotedNumber[1] }); } return undefined; } }, {"./catalog":"diagnostics/catalog.js","./classify":"diagnostics/classify.js","./suggest":"diagnostics/suggest.js","./text":"diagnostics/text.js","./format":"diagnostics/format.js","./types":"diagnostics/types.js"}, ], "diagnostics/problems.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Problems = void 0; exports.localizedMessages = localizedMessages; const format_1 = require("./format"); const index_1 = require("./index"); /** The problems of a compilation, per entry of its `errors` and `warnings`. */ class Problems { constructor() { this.entries = []; } add(entry) { this.entries.push(entry); } diagnostics(source, language) { const all = this.entries.map((entry) => { switch (entry.kind) { case 'syntax': return (0, index_1.syntaxDiagnostic)(entry.text, source, language); case 'codegen': return (0, index_1.codegenDiagnostic)(entry.text, source, language); case 'type': return (0, index_1.typeDiagnostic)(entry.error, source, language); case 'target': return (0, index_1.detailDiagnostic)('TARGET_UNSUPPORTED', entry.text, language, entry); case 'option': return (0, index_1.detailDiagnostic)('OPTION_INVALID', entry.text, language); case 'detail': return (0, index_1.detailDiagnostic)(entry.id, entry.text, language); default: return (0, index_1.detailDiagnostic)('CODEGEN_INVALID', entry.text, language); } }); // After a syntax error the parser goes on from a guess; what it reports next on that // line is mostly the same mistake again (`чоп(1; 2)`: a `)` and a `;`) const shown = all.filter((d, index) => this.entries[index].kind !== 'syntax' || !all .slice(0, index) .some((e, before) => this.entries[before].kind === 'syntax' && e.line === d.line)); return [ ...shown.filter(d => d.severity === 'error'), ...shown.filter(d => d.severity === 'warning'), ]; } } exports.Problems = Problems; /** A result's `errors` and `warnings` in `language`, for learners, and the diagnostics. */ function localizedMessages(diagnostics, source, language) { const format = (d) => (0, format_1.formatDiagnostic)(d, { language, source }); return { errors: diagnostics.filter(d => d.severity === 'error').map(format), warnings: diagnostics.filter(d => d.severity === 'warning').map(format), diagnostics, }; } }, {"./format":"diagnostics/format.js","./index":"diagnostics/index.js"}, ], "diagnostics/suggest.js": [ function (module, exports, require) { "use strict"; /** * "Did you mean …?": the name or keyword closest to what the learner wrote, * and the SomonScript word for an English keyword they may know. */ Object.defineProperty(exports, "__esModule", { value: true }); exports.ENGLISH_WORDS = exports.STATEMENT_KEYWORDS = void 0; exports.editDistance = editDistance; exports.closestName = closestName; /** Keywords a statement starts with, or that learners write on their own. */ exports.STATEMENT_KEYWORDS = [ 'агар', 'вагарна', 'барои', 'тағ', 'собит', 'функсия', 'бозгашт', 'синф', 'кӯшиш', 'гирифтан', 'ниҳоят', 'интихоб', 'ҳолат', 'пешфарз', 'шикастан', 'давом', 'партофтан', 'ворид', 'содир', 'чоп', 'дуруст', 'нодуруст', 'холӣ', 'беқимат', 'ҳамзамон', 'интизор', 'интерфейс', ]; /** English (JavaScript) words and the SomonScript words for them. */ exports.ENGLISH_WORDS = new Map([ ['if', 'агар'], ['else', 'вагарна'], ['for', 'барои'], ['while', 'то'], ['let', 'тағ'], ['var', 'тағ'], ['const', 'собит'], ['function', 'функсия'], ['return', 'бозгашт'], ['class', 'синф'], ['try', 'кӯшиш'], ['catch', 'гирифтан'], ['finally', 'ниҳоят'], ['switch', 'интихоб'], ['case', 'ҳолат'], ['break', 'шикастан'], ['continue', 'давом'], ['throw', 'партофтан'], ['import', 'ворид'], ['export', 'содир'], ['print', 'чоп'], ['console', 'чоп'], ['true', 'дуруст'], ['false', 'нодуруст'], ['null', 'холӣ'], ['undefined', 'беқимат'], ]); /** * Edits (insert, delete, replace, swap two neighbours) that turn `a` into * `b`, ignoring case. */ function editDistance(a, b) { const s = [...a.toLowerCase()]; const t = [...b.toLowerCase()]; // d[i][j]: distance of the first i characters of s and the first j of t const d = Array.from({ length: s.length + 1 }, (_, i) => [i]); for (let j = 1; j <= t.length; j++) d[0][j] = j; for (let i = 1; i <= s.length; i++) { for (let j = 1; j <= t.length; j++) { const cost = s[i - 1] === t[j - 1] ? 0 : 1; d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost); if (i > 1 && j > 1 && s[i - 1] === t[j - 2] && s[i - 2] === t[j - 1]) { d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1); } } } return d[s.length][t.length]; } /** How many edits apart two names of (at most) this length may be. */ function allowedEdits(length) { if (length <= 2) return 0; return length <= 4 ? 1 : 2; } /** * The candidate closest to `word`, within the edits the longer of the two * allows; the first of equally close ones, and none for `word` itself. */ function closestName(word, candidates) { let best; let bestDistance = Infinity; const length = [...word].length; for (const candidate of candidates) { if (candidate === word) continue; const distance = editDistance(word, candidate); const allowed = allowedEdits(Math.max(length, [...candidate].length)); if (distance <= allowed && distance < bestDistance) { best = candidate; bestDistance = distance; } } return best; } }, {}, ], "diagnostics/text.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.code = code; exports.codes = codes; exports.text = text; exports.isLiteralType = isLiteralType; exports.tajikType = tajikType; exports.russianPlural = russianPlural; exports.nameLength = nameLength; /** Code in a message: `` `агар` ``. */ function code(value) { return `\`${String(value)}\``; } const OR = { en: 'or', ru: 'или', tj: 'ё' }; /** `` `а` ``, `` `а` ё `б` ``, … for one value or a list of them. */ function codes(value, language) { const values = Array.isArray(value) ? value : [String(value)]; return values.map(code).join(` ${OR[language]} `); } /** A parameter as a string ('' when absent). */ function text(value) { if (value === undefined) return ''; return Array.isArray(value) ? value.join(', ') : String(value); } /** * Whether a type, as the checker prints it, is the type of one value: a string * or number literal (`"панҷ"`, `5`) or a boolean one. */ function isLiteralType(type) { return /^(".*"|-?\d[\d.e+_]*n?|true|false)$/.test(text(type)); } /** * A type as SomonScript writes it: the checker prints boolean literal types as * `true`/`false`, the language spells them `дуруст`/`нодуруст` (strings in the * type are left alone). */ function tajikType(type) { return text(type).replace(/"(?:[^"\\]|\\.)*"|\b(true|false)\b/g, (match, word) => { if (!word) return match; return word === 'true' ? 'дуруст' : 'нодуруст'; }); } /** Russian noun forms after a number: 1 ошибка, 2 ошибки, 5 ошибок. */ function russianPlural(count, forms) { const tens = count % 100; const units = count % 10; if (tens >= 11 && tens <= 14) return forms[2]; if (units === 1) return forms[0]; if (units >= 2 && units <= 4) return forms[1]; return forms[2]; } /** How long the name or string at a position is (1 for anything else). */ function nameLength(source, line, column) { if (line === undefined || column === undefined) return undefined; const rest = (source.split(/\r?\n/)[line - 1] ?? '').slice(column - 1); const word = /^(?:[\p{L}\p{N}_$]+|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/u.exec(rest); return word ? [...word[0]].length : 1; } }, {}, ], "diagnostics/types.js": [ function (module, exports, require) { "use strict"; /** * Diagnostics as data: a stable code, the message in the requested language, * where it is, and a hint. The compiler's English strings (`errors`, * `warnings` of `compile()`) stay as they were for callers that ask for no * language; `compile(source, { language })` returns these (`diagnostics`). */ Object.defineProperty(exports, "__esModule", { value: true }); exports.DIAGNOSTIC_LANGUAGES = void 0; exports.DIAGNOSTIC_LANGUAGES = ['en', 'ru', 'tj']; }, {}, ], "handlers/declaration-handler.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.DeclarationHandler = void 0; const types_1 = require("../types"); class DeclarationHandler { constructor(parser) { this.parser = parser; } parseStatement() { if (this.parser.match(types_1.TokenType.НОМФАЗО)) { return this.parser.namespaceDeclaration(); } if (this.parser.match(types_1.TokenType.ИНТЕРФЕЙС)) { return this.parser.interfaceDeclaration(); } if (this.parser.match(types_1.TokenType.НАВЪ)) { return this.parser.typeAlias(); } // `мавҳум синф`; `мавҳум` (or `abstract`) alone is a name if (this.parser.checkSequence(types_1.TokenType.МАВҲУМ, types_1.TokenType.СИНФ)) { this.parser.match(types_1.TokenType.МАВҲУМ); this.parser.consume(types_1.TokenType.СИНФ, "Expected 'синф' after 'мавҳум'"); const classDecl = this.parser.classDeclaration(); classDecl.abstract = true; return classDecl; } if (this.parser.match(types_1.TokenType.СИНФ)) { return this.parser.classDeclaration(); } if (this.parser.match(types_1.TokenType.ТАҒЙИРЁБАНДА, types_1.TokenType.СОБИТ)) { return this.parser.variableDeclaration(); } // `ҳамзамон () => …` is an expression; only `ҳамзамон функсия` declares if (this.parser.isAsyncFunctionStart()) { // 'ҳамзамон', or the word 'async' if (!this.parser.match(types_1.TokenType.ҲАМЗАМОН)) this.parser.match(types_1.TokenType.IDENTIFIER); this.parser.consume(types_1.TokenType.ФУНКСИЯ, "Expected 'функсия' after 'ҳамзамон'"); const func = this.parser.functionDeclaration(); func.async = true; return func; } if (this.parser.match(types_1.TokenType.ФУНКСИЯ)) { return this.parser.functionDeclaration(); } return null; } } exports.DeclarationHandler = DeclarationHandler; }, {"../types":"types.js"}, ], "handlers/import-handler.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.ImportHandler = void 0; const types_1 = require("../types"); class ImportHandler { constructor(parser) { this.parser = parser; } parseStatement() { // `ворид(…)` (dynamic import) and `ворид.meta` start expression statements if (this.parser.checkSequence(types_1.TokenType.ВОРИД, types_1.TokenType.LEFT_PAREN) || this.parser.checkSequence(types_1.TokenType.ВОРИД, types_1.TokenType.DOT)) { return null; } if (this.parser.match(types_1.TokenType.ВОРИД)) { return this.parser.importDeclaration(); } if (this.parser.match(types_1.TokenType.СОДИР)) { return this.parser.exportDeclaration(); } return null; } } exports.ImportHandler = ImportHandler; }, {"../types":"types.js"}, ], "handlers/loop-handler.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.LoopHandler = void 0; const types_1 = require("../types"); class LoopHandler { constructor(parser) { this.parser = parser; } parseStatement() { if (this.parser.match(types_1.TokenType.ТО)) { return this.parser.whileStatement(); } if (this.parser.match(types_1.TokenType.БАРОИ)) { return this.parser.forStatement(); } return null; } } exports.LoopHandler = LoopHandler; }, {"../types":"types.js"}, ], "keyword-map.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.KEYWORDS = void 0; const tokens_1 = require("./tokens"); exports.KEYWORDS = new Map([ // Core language keywords ['тағйирёбанда', tokens_1.TokenType.ТАҒЙИРЁБАНДА], ['тағ', tokens_1.TokenType.ТАҒЙИРЁБАНДА], // Short form of тағйирёбанда ['собит', tokens_1.TokenType.СОБИТ], ['функсия', tokens_1.TokenType.ФУНКСИЯ], ['функция', tokens_1.TokenType.ФУНКСИЯ], // Alternative spelling ['агар', tokens_1.TokenType.АГАР], ['вагарна', tokens_1.TokenType.ВАГАРНА], ['чунин', tokens_1.TokenType.ЧУНИН], ['барои', tokens_1.TokenType.БАРОИ], ['то', tokens_1.TokenType.ТО], ['бозгашт', tokens_1.TokenType.БОЗГАШТ], ['синф', tokens_1.TokenType.СИНФ], ['нав', tokens_1.TokenType.НАВ], ['ин', tokens_1.TokenType.ИН], ['дуруст', tokens_1.TokenType.ДУРУСТ], ['нодуруст', tokens_1.TokenType.НОДУРУСТ], ['холӣ', tokens_1.TokenType.ХОЛӢ], ['беқимат', tokens_1.TokenType.БЕҚИМАТ], // Import/Export ['ворид', tokens_1.TokenType.ВОРИД], ['содир', tokens_1.TokenType.СОДИР], ['аз', tokens_1.TokenType.АЗ], ['дар', tokens_1.TokenType.ДАР], ['пешфарз', tokens_1.TokenType.ПЕШФАРЗ], ['чун', tokens_1.TokenType.ЧУН], // Built-in functions ['чоп', tokens_1.TokenType.ЧОП], ['сабт', tokens_1.TokenType.САБТ], ['хато', tokens_1.TokenType.ХАТО], ['огоҳӣ', tokens_1.TokenType.ОГОҲӢ], ['маълумот', tokens_1.TokenType.МАЪЛУМОТ], ['исфти', tokens_1.TokenType.ИСФТИ], ['тасдиқ', tokens_1.TokenType.ТАСДИҚ], ['қайд', tokens_1.TokenType.ҚАЙД], ['қайдАсл', tokens_1.TokenType.ҚАЙДАСЛ], ['қайдасл', tokens_1.TokenType.ҚАЙДАСЛ], // Lowercase version ['вақт', tokens_1.TokenType.ВАҚТ], ['вақтСабт', tokens_1.TokenType.ВАҚТСАБТ], ['вақтсабт', tokens_1.TokenType.ВАҚТСАБТ], // Lowercase version ['вақтОхир', tokens_1.TokenType.ВАҚТОХИР], ['вақтохир', tokens_1.TokenType.ВАҚТОХИР], // Lowercase version ['ҷадвал', tokens_1.TokenType.ҶАДВАЛ], ['феҳрист', tokens_1.TokenType.ФЕҲРИСТ], ['xmlФеҳрист', tokens_1.TokenType.XMLФЕҲРИСТ], ['xmlфеҳрист', tokens_1.TokenType.XMLФЕҲРИСТ], // Lowercase version ['пайҷо', tokens_1.TokenType.ПАЙҶО], ['полиз', tokens_1.TokenType.ПОЛИЗ], ['гуруҳ', tokens_1.TokenType.ГУРУҲ], ['гуруҳОхир', tokens_1.TokenType.ГУРУҲОХИР], ['гуруҳохир', tokens_1.TokenType.ГУРУҲОХИР], // Lowercase version ['гуруҳПӯшида', tokens_1.TokenType.ГУРУҲПӮШИДА], ['гуруҳпӯшида', tokens_1.TokenType.ГУРУҲПӮШИДА], // Lowercase version // Array methods ['рӯйхат', tokens_1.TokenType.РӮЙХАТ], ['илова', tokens_1.TokenType.ИЛОВА], ['баровардан', tokens_1.TokenType.БАРОВАРДАН], ['дарозӣ', tokens_1.TokenType.ДАРОЗӢ], ['харита', tokens_1.TokenType.ХАРИТА], ['филтр', tokens_1.TokenType.ФИЛТР], ['кофтан', tokens_1.TokenType.КОФТАН], // String methods (camelCase following TypeScript conventions) ['сатрМетодҳо', tokens_1.TokenType.САТРМЕТОДҲО], ['сатрметодҳо', tokens_1.TokenType.САТРМЕТОДҲО], // Lowercase version ['дарозииСатр', tokens_1.TokenType.ДАРОЗИИСАТР], ['дарозиисатр', tokens_1.TokenType.ДАРОЗИИСАТР], // Lowercase version ['пайвастан', tokens_1.TokenType.ПАЙВАСТАН], ['ҷойивазкунӣ', tokens_1.TokenType.ҶОЙИВАЗКУНӢ], ['ҷудокунӣ', tokens_1.TokenType.ҶУДОКУНӢ], // Object methods ['калидҳо', tokens_1.TokenType.КАЛИДҲО], ['қиматҳо', tokens_1.TokenType.ҚИМАТҲО], // Math ['математика', tokens_1.TokenType.МАТЕМАТИКА], ['ҷамъ', tokens_1.TokenType.ҶАМЪ], ['тарҳ', tokens_1.TokenType.ТАРҲ], ['зарб', tokens_1.TokenType.ЗАРБ], ['тақсим', tokens_1.TokenType.ТАҚСИМ], // Control flow ['шикастан', tokens_1.TokenType.ШИКАСТАН], ['давом', tokens_1.TokenType.ДАВОМ], ['интихоб', tokens_1.TokenType.ИНТИХОБ], ['ҳолат', tokens_1.TokenType.ҲОЛАТ], ['кӯшиш', tokens_1.TokenType.КӮШИШ], ['гирифтан', tokens_1.TokenType.ГИРИФТАН], ['ниҳоят', tokens_1.TokenType.НИҲОЯТ], ['партофтан', tokens_1.TokenType.ПАРТОФТАН], // Async ['ҳамзамон', tokens_1.TokenType.ҲАМЗАМОН], ['интизор', tokens_1.TokenType.ИНТИЗОР], ['ваъда', tokens_1.TokenType.ВАЪДА], // Type system - Primitive Types ['сатр', tokens_1.TokenType.САТР], ['рақам', tokens_1.TokenType.РАҚАМ], ['мантиқӣ', tokens_1.TokenType.МАНТИҚӢ], ['калонрақам', tokens_1.TokenType.КАЛОНРАҚАМ], ['рамз', tokens_1.TokenType.РАМЗ], // Type system - Special Types ['ҳар', tokens_1.TokenType.ҲАР], ['ношинос', tokens_1.TokenType.НОШИНОС], ['абадан', tokens_1.TokenType.АБАДАН], ['беджавоб', tokens_1.TokenType.БЕДЖАВОБ], ['объект', tokens_1.TokenType.ОБЪЕКТ], // Type system - Core Keywords ['интерфейс', tokens_1.TokenType.ИНТЕРФЕЙС], ['навъ', tokens_1.TokenType.НАВЪ], ['якхела', tokens_1.TokenType.ЯКХЕЛА], ['мерос', tokens_1.TokenType.МЕРОС], ['татбиқ', tokens_1.TokenType.ТАТБИҚ], ['супер', tokens_1.TokenType.СУПЕР], ['конструктор', tokens_1.TokenType.КОНСТРУКТОР], ['хосусӣ', tokens_1.TokenType.ХОСУСӢ], ['муҳофизатшуда', tokens_1.TokenType.МУҲОФИЗАТШУДА], ['ҷамъиятӣ', tokens_1.TokenType.ҶАМЪИЯТӢ], ['статикӣ', tokens_1.TokenType.СТАТИКӢ], ['мавҳум', tokens_1.TokenType.МАВҲУМ], ['номфазо', tokens_1.TokenType.НОМФАЗО], ['калидҳои', tokens_1.TokenType.КАЛИДҲОИ], ['инфер', tokens_1.TokenType.ИНФЕР], ['хулоса', tokens_1.TokenType.ХУЛОСА], ['танҳохонӣ', tokens_1.TokenType.ТАНҲОХОНӢ], ['беназир', tokens_1.TokenType.БЕНАЗИР], ['навъи', tokens_1.TokenType.НАВЪИ], ['аст', tokens_1.TokenType.АСТ], ['бармесоё', tokens_1.TokenType.БАРМЕСОЁ], // Type system - Utility Types ['қисмӣ', tokens_1.TokenType.ҚИСМӢ], ['ҳатмӣ', tokens_1.TokenType.ҲАТМӢ], ['танҳохон', tokens_1.TokenType.ТАНҲОХОН], ['сабт_навъ', tokens_1.TokenType.САБТ_НАВЪ], ['гирифтан_навъ', tokens_1.TokenType.ГИРИФТАН_НАВЪ], ['ҳазф', tokens_1.TokenType.ҲАЗФ], ['хориҷ', tokens_1.TokenType.ХОРИҶ], ['истихроҷ', tokens_1.TokenType.ИСТИХРОҶ], ['беналиӣ', tokens_1.TokenType.БЕНАЛИӢ], ['навъи_бозгашт', tokens_1.TokenType.НАВЪИ_БОЗГАШТ], ['параметрҳо', tokens_1.TokenType.ПАРАМЕТРҲО], ['навъи_намуна', tokens_1.TokenType.НАВЪИ_НАМУНА], ['параметрҳои_конструктор', tokens_1.TokenType.ПАРАМЕТРҲОИ_КОНСТРУКТОР], ['навъи_параметри_ин', tokens_1.TokenType.НАВЪИ_ПАРАМЕТРИ_ИН], ['интизоршуда', tokens_1.TokenType.ИНТИЗОРШУДА], ]); }, {"./tokens":"tokens.js"}, ], "learner/warnings.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.checkForLearners = checkForLearners; exports.learnerWarnings = learnerWarnings; const builtin_names_1 = require("../builtin-names"); const catalog_1 = require("../diagnostics/catalog"); const type_checker_1 = require("../type-checker"); const ARITHMETIC = new Set(['-', '*', '/', '%', '**']); const STRICT_EQUALITY = new Set(['===', '!==']); /** AST keys that hold types, which do not read variables. */ const TYPE_KEYS = new Set([ 'typeAnnotation', 'returnType', 'typeParameters', 'typeArguments', 'superTypeArguments', 'implements', ]); /** SomonScript's names of the primitive types the warnings compare. */ const TYPE_NAMES = { string: 'сатр', number: 'рақам' }; /** Type checks `program`, with the warnings of the learning mode among the warnings. */ function checkForLearners(program, source, strict) { const binaries = new Map(); const result = new type_checker_1.TypeChecker(source, { strict, onBinaryTypes: (binary, left, right) => binaries.set(binary, [left, right]), }).check(program); const warnings = [...result.warnings, ...learnerWarnings(program, source, binaries)]; warnings.sort((a, b) => a.line - b.line || a.column - b.column); return { errors: result.errors, warnings }; } /** The warnings of the learning mode, given the operand types of the binary expressions. */ function learnerWarnings(program, source, binaries) { const lines = source.split(/\r?\n/); const facts = collect(program); const warnings = []; const warn = (node, msg) => { warnings.push({ code: msg.id, message: (0, catalog_1.renderMessage)(msg, 'en'), line: node.line, column: node.column, snippet: lines[node.line - 1], severity: 'warning', messageId: msg.id, params: msg.params, }); }; for (const [binary, [left, right]] of binaries) { const op = binary.operator; const types = [primitive(left), primitive(right)]; if (ARITHMETIC.has(op) && types.includes('string')) { warn(binary, (0, catalog_1.message)('LEARNER_STRING_ARITHMETIC', { operator: op })); } else if (op === '+') { const read = [binary.left, binary.right].findIndex(operand => facts.readsLine(operand)); if (read !== -1 && types[1 - read] === 'number') { warn(read === 0 ? binary.left : binary.right, (0, catalog_1.message)('LEARNER_STRING_PLUS_NUMBER')); } } else if (STRICT_EQUALITY.has(op) && types[0] && types[1] && types[0] !== types[1]) { warn(binary, (0, catalog_1.message)('LEARNER_COMPARE_TYPES', { left: TYPE_NAMES[types[0]], right: TYPE_NAMES[types[1]], operator: op, })); } } for (const declaration of facts.unused()) { const id = declaration.identifier; warn(id, (0, catalog_1.message)('LEARNER_UNUSED_VARIABLE', { name: id.name })); } for (const key of facts.builtinMemberKeys) { warn(key, (0, catalog_1.message)('LEARNER_BUILTIN_MEMBER_NAME', { name: key.name, js: builtin_names_1.BUILTIN_MAPPINGS.get(key.name), })); } return warnings; } /** `string` or `number` when a type is one of them (or a literal of one). */ function primitive(type) { const name = type.kind === 'literal' ? typeof type.value : type.name; if (type.kind !== 'primitive' && type.kind !== 'literal') return undefined; return name === 'string' || name === 'number' ? name : undefined; } /** What the program declares and reads, found in one walk of its syntax tree. */ function collect(program) { const declarations = []; const reads = new Set(); /** Variables whose value is a line read with `хондан()`. */ const lineVariables = new Set(); const declaredNames = new Set(); const builtinMemberKeys = []; /** Declarations of `содир тағ …` and `содир собит …`, which other modules use. */ const exported = new WeakSet(); const isReadCall = (node) => node?.type === 'CallExpression' && node.callee.type === 'Identifier' && node.callee.name === 'хондан'; const visit = (node, parent, key) => { noteNode(node, parent, key); for (const [childKey, value] of Object.entries(node)) { if (TYPE_KEYS.has(childKey)) continue; for (const child of Array.isArray(value) ? value : [value]) { if (child && typeof child === 'object' && typeof child.type === 'string') { visit(child, node, childKey); } } } }; const noteNode = (node, parent, key) => { switch (node.type) { case 'ExportDeclaration': { // Seen before the declarations in it const declaration = node.declaration; const list = declaration?.declarations; for (const exportedNode of list ?? (declaration ? [declaration] : [])) { exported.add(exportedNode); } break; } case 'VariableDeclaration': noteDeclaration(node); break; case 'FunctionDeclaration': declaredNames.add(node.name.name); break; case 'Identifier': // An identifier is never the root of the tree if (isRead(parent, key)) reads.add(node.name); break; case 'Property': noteKey(node, !node.computed && !node.method); break; case 'PropertyDefinition': noteKey(node, !node.computed); break; } }; const noteDeclaration = (declaration) => { if (declaration.identifier.type !== 'Identifier') return; const name = declaration.identifier.name; declaredNames.add(name); if (isReadCall(declaration.init)) lineVariables.add(name); // `содир` inside a `номфазо` marks the declaration itself const inNamespace = declaration.exported; if (!exported.has(declaration) && !inNamespace && !declaration.declare && !name.startsWith('_')) { declarations.push(declaration); } }; const noteKey = (node, named) => { const key = node.key; // Only data: a method of that name (`баСатр()`) is meant to be the built-in one const data = node.type === 'PropertyDefinition' || node.value?.type !== 'FunctionExpression'; if (named && data && key.type === 'Identifier' && builtin_names_1.MEMBER_ALIASES.has(key.name)) { builtinMemberKeys.push(key); } }; visit(program); // A program that declares its own `хондан` reads no input with it const readsInput = !declaredNames.has('хондан'); return { builtinMemberKeys, unused: () => declarations.filter(d => !reads.has(d.identifier.name)), readsLine: (node) => readsInput && (isReadCall(node) || (node.type === 'Identifier' && lineVariables.has(node.name))), }; } /** Whether an identifier at `key` of `parent` reads a variable (not a name being declared, a key or a member). */ function isRead(parent, key) { switch (parent.type) { case 'VariableDeclaration': return key !== 'identifier'; case 'MemberExpression': return key !== 'property' || parent.computed; case 'Property': return key !== 'key' || parent.computed; case 'PropertyDefinition': case 'MethodDefinition': return key !== 'key'; case 'FunctionDeclaration': case 'ClassDeclaration': return key !== 'name'; default: return true; } } }, {"../builtin-names":"builtin-names.js","../diagnostics/catalog":"diagnostics/catalog.js","../type-checker":"type-checker.js"}, ], "lexer.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Lexer = void 0; exports.regexLiteralEnd = regexLiteralEnd; exports.isRegexStartInText = isRegexStartInText; const types_1 = require("./types"); const keyword_map_1 = require("./keyword-map"); function isLineTerminator(char) { return char === '\n' || char === '\r' || char === '\u2028' || char === '\u2029'; } /** * Index just past the regular expression literal whose opening '/' is at * `start` (flags included), or -1 when the line ends before its closing '/'. * A '/' inside a character class (`/[/]/`) or escaped (`/\//`) does not close it. */ function regexLiteralEnd(text, start) { let inClass = false; let i = start + 1; for (; i < text.length && (text[i] !== '/' || inClass); i++) { const char = text[i]; if (char === '\\') i++; else if (char === '[') inClass = true; else if (char === ']') inClass = false; if (i >= text.length || isLineTerminator(text[i])) return -1; } if (i >= text.length) return -1; i++; while (i < text.length && /[\p{ID_Continue}$]/u.test(text[i])) i++; return i; } /** * Whether the '/' at `index` of raw source text starts a regular expression, * judged by the last character since `start` that is not blank or in a block * comment: after an operator or an opening bracket it does, after an operand * (`а / 2`, `(а) / 2`, `а++ / 2`, `а! / 2`, `{} / 2`) it is a division. Used * where template interpolations are scanned as text. */ function isRegexStartInText(text, index, start) { let i = previousSignificant(text, index - 1, start); if (i < start) return true; const previous = text[i]; if ((previous === '+' || previous === '-') && text[i - 1] === previous) return false; if (previous === '!') { // `х! / 2`: a `!` after an operand on the same line is the postfix non-null assertion while (i > start && /[! \t]/.test(text[i - 1])) i--; return i === start || !/[\p{L}\p{N}\p{M}_$)\]"'`]/u.test(text[i - 1]); } // `{ а: 1 } / 2` divides an object literal; a block (`агар (х) {}`) ends a statement if (previous === '}') { return !opensObjectLiteralInText(text, matchingOpenBrace(text, i, start), start); } return '(,=:[&|?{};+-*%<>~^'.includes(previous); } /** * Index of the last character at or before `i` (down to `start`) that is not * blank or in a block comment; below `start` when there is none. */ function previousSignificant(text, i, start) { while (i >= start) { if (/\s/.test(text[i])) { i--; } else if (text[i] === '/' && text[i - 1] === '*' && i - 1 > start) { const open = text.lastIndexOf('/*', i - 2); if (open < start) return i; i = open - 1; } else { return i; } } return i; } /** Index of the '{' that the '}' at `close` closes; below `start` when it is not in the text. */ function matchingOpenBrace(text, close, start) { let depth = 0; for (let i = close; i >= start; i--) { if (text[i] === '}') depth++; else if (text[i] === '{' && --depth === 0) return i; } return start - 1; } /** Whether the '{' at `open` opens an object literal: an operand is expected there (not `=> {`). */ function opensObjectLiteralInText(text, open, start) { if (open < start) return false; const i = previousSignificant(text, open - 1, start); return i < start || '(,=:[&|?+-*%<~^!'.includes(text[i]); } class Lexer { constructor(input, options = {}) { /** Offset where the token being read starts (comment mode). */ this.tokenStart = 0; this.position = 0; this.line = 1; this.column = 1; this.keywords = keyword_map_1.KEYWORDS; /** Whether a '/' at this point starts a regular expression rather than a division. */ this.regexAllowed = true; /** Line on which `previousToken` ends. */ this.previousTokenEndLine = 1; /** * For each open '(' '[' '{': whether a '/' right after its closing bracket * starts a regex, and whether it opens the body of a generator. */ this.openBrackets = []; /** Open generator bodies; in them `ҳосил` / `yield` is the yield operator. */ this.generatorBodies = 0; /** A `*` marked a generator (`функсия*`, `*ном() {…}`): the next block is its body. */ this.generatorPending = false; // Remove BOM if present this.input = input.codePointAt(0) === 0xfeff ? input.slice(1) : input; this.keepComments = options.comments === true; this.expressionInput = options.expression === true; } tokenize() { const tokens = []; // `#!/usr/bin/env node`: only on the very first line, as in JavaScript if (this.input.startsWith('#!')) { const shebang = this.readShebang(); if (this.keepComments) Object.assign(shebang, { start: 0, end: this.position }); tokens.push(shebang); } while (!this.isAtEnd()) { const token = this.keepComments ? this.nextTokenOrComment() : this.nextToken(); if (token.type !== types_1.TokenType.WHITESPACE) { if (this.keepComments) { token.start = this.tokenStart; token.end = this.position; } tokens.push(token); if (token.type !== types_1.TokenType.NEWLINE && token.type !== types_1.TokenType.COMMENT) { this.trackRegexContext(token); this.previousTokenEndLine = this.line; } } } const eof = this.createToken(types_1.TokenType.EOF, ''); if (this.keepComments) { eof.start = this.position; eof.end = this.position; } tokens.push(eof); return tokens; } handlePlusOperator() { if (this.peek() === '+') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.INCREMENT, '++', this.line, this.column - 2); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.PLUS_ASSIGN, '+=', this.line, this.column - 2); } return this.singleCharToken(types_1.TokenType.PLUS); } handleMinusOperator() { if (this.peek() === '-') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.DECREMENT, '--', this.line, this.column - 2); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.MINUS_ASSIGN, '-=', this.line, this.column - 2); } return this.singleCharToken(types_1.TokenType.MINUS); } handleMultiplyOperator() { if (this.peek() === '*') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.EXPONENT_ASSIGN, '**=', this.line, this.column - 3); } this.advance(); return this.createToken(types_1.TokenType.EXPONENT, '**', this.line, this.column - 2); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.MULTIPLY_ASSIGN, '*=', this.line, this.column - 2); } return this.singleCharToken(types_1.TokenType.MULTIPLY); } handleDivideOperator() { const regex = this.regexAllowed ? this.readRegularExpression() : undefined; if (regex) return regex; if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.DIVIDE_ASSIGN, '/=', this.line, this.column - 2); } return this.singleCharToken(types_1.TokenType.DIVIDE); } /** * Reads the regular expression literal starting at the current '/'. When the * line ends before its closing '/', returns undefined: the '/' is then read * as a division operator, which the parser reports where an operand belongs. */ readRegularExpression() { const end = regexLiteralEnd(this.input, this.position); if (end === -1) return undefined; const line = this.line; const column = this.column; const text = this.input.slice(this.position, end); const closing = text.lastIndexOf('/'); Lexer.validateRegularExpression(text.slice(1, closing), text.slice(closing + 1), line, column); while (this.position < end) this.advanceCodePoint(); return this.createToken(types_1.TokenType.REGEX, text, line, column); } /** Invalid flags or pattern syntax are early errors in JavaScript. */ static validateRegularExpression(pattern, flags, line, column) { if (!/^[dgimsuyv]*$/.test(flags) || new Set(flags).size !== flags.length || (flags.includes('u') && flags.includes('v'))) { throw new Error(`Invalid regular expression flags '${flags}' at line ${line}, column ${column}`); } try { new RegExp(pattern, flags); } catch (error) { // The RegExp constructor throws a SyntaxError throw new Error(`${error.message} at line ${line}, column ${column}`); } } /** * Records whether a '/' after `token` starts a regular expression (an operand * is expected: after an operator, an opening bracket, `бозгашт`, …) or is a * division (an operand just ended: a name, a literal, `)`, `]`, `а++`). */ trackRegexContext(token) { const before = this.regexAllowed; const previous = this.previousToken; this.previousToken = token; if (Lexer.CONTEXT_KEEPING_TOKENS.has(token.type)) { // A `!` starting a line is a prefix `!`, never a postfix non-null assertion if (token.type === types_1.TokenType.NOT && token.line > this.previousTokenEndLine) { this.regexAllowed = true; } return; } if (Lexer.CLOSING_BRACKETS.has(token.type)) { const open = this.openBrackets.pop(); if (open?.generatorBody) this.generatorBodies--; this.regexAllowed = open?.regexAfterClose ?? token.type === types_1.TokenType.RIGHT_BRACE; } else if (Lexer.OPERAND_TOKENS.has(token.type)) { this.regexAllowed = false; } else if (/^[\p{ID_Start}$_#]/u.test(token.value)) { this.regexAllowed = this.regexAllowedAfterWord(token, before, previous); } else { this.trackPunctuator(token, before, previous); this.regexAllowed = true; } } /** * Remembers, for an opening bracket, whether a '/' after its closing bracket * starts a regex, and notes generator markers and bodies. */ trackPunctuator(token, before, previous) { switch (token.type) { case types_1.TokenType.LEFT_PAREN: // `агар (…) /…/` starts a statement; `ф(…) / 2` divides this.openBrackets.push({ regexAfterClose: previous !== undefined && Lexer.CONDITION_KEYWORDS.has(previous.type), generatorBody: false, }); break; case types_1.TokenType.LEFT_BRACKET: this.openBrackets.push({ regexAfterClose: false, generatorBody: false }); break; case types_1.TokenType.LEFT_BRACE: { const block = previous === undefined ? !this.expressionInput : !Lexer.opensObjectLiteral(before, previous); const generatorBody = block && this.generatorPending; if (generatorBody) { this.generatorPending = false; this.generatorBodies++; } this.openBrackets.push({ regexAfterClose: block, generatorBody }); break; } case types_1.TokenType.MULTIPLY: // A `*` where no operand precedes it marks a generator (but `ҳосил* х` delegates) if (previous !== undefined && (Lexer.GENERATOR_STAR_WORDS.has(previous.value) || (before && !Lexer.YIELD_WORDS.has(previous.value)))) { this.generatorPending = true; } break; } } regexAllowedAfterWord(token, before, previous) { // A property name: `о.бозгашт / 2` if (previous?.type === types_1.TokenType.DOT || previous?.type === types_1.TokenType.OPTIONAL_CHAINING) { return false; } // `ҳосил /…/` yields a regex in a generator; elsewhere `ҳосил` is a name if (Lexer.YIELD_WORDS.has(token.value)) return this.generatorBodies > 0; if (Lexer.OPERATOR_WORDS.has(token.value)) return true; // `х дар /…/` is an operator; a variable named `дар` is an operand if (Lexer.INFIX_WORDS.has(token.value)) return !before; // `ҳолат /…/:` starts a switch case; elsewhere `ҳолат` is an ordinary name if (token.value === 'ҳолат' || token.value === 'case') { return previous === undefined || [';', '{', '}', ':'].includes(previous.value); } return false; } /** Whether a '{' after `previous` opens an object literal (an operand) rather than a block. */ static opensObjectLiteral(before, previous) { if (!before || previous === undefined) return false; if (previous.type === types_1.TokenType.SEMICOLON || previous.type === types_1.TokenType.LEFT_BRACE || previous.type === types_1.TokenType.RIGHT_BRACE || previous.type === types_1.TokenType.RIGHT_PAREN || previous.type === types_1.TokenType.ARROW || previous.type === types_1.TokenType.GREATER_THAN) { return false; } return !Lexer.BLOCK_WORDS.has(previous.value); } handleModuloOperator() { if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.MODULO_ASSIGN, '%=', this.line, this.column - 2); } return this.singleCharToken(types_1.TokenType.MODULO); } handleDotOperator() { if (this.peekNext() === '.' && this.peekNext(1) === '.') { this.advance(); this.advance(); this.advance(); return this.createToken(types_1.TokenType.SPREAD, '...', this.line, this.column - 3); } return this.singleCharToken(types_1.TokenType.DOT); } handleEqualOperator(startLine, startColumn) { if (this.peek() === '=') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.STRICT_EQUAL, '===', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.EQUAL, '==', startLine, startColumn); } if (this.peek() === '>') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.ARROW, '=>', startLine, startColumn); } return this.singleCharToken(types_1.TokenType.ASSIGN); } handleNotOperator(startLine, startColumn) { if (this.peek() === '=') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.STRICT_NOT_EQUAL, '!==', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.NOT_EQUAL, '!=', startLine, startColumn); } return this.singleCharToken(types_1.TokenType.NOT); } handleLessThanOperator(startLine, startColumn) { if (this.peek() === '<') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.LEFT_SHIFT_ASSIGN, '<<=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.LEFT_SHIFT, '<<', startLine, startColumn); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.LESS_EQUAL, '<=', startLine, startColumn); } return this.singleCharToken(types_1.TokenType.LESS_THAN); } handleGreaterThanOperator(startLine, startColumn) { if (this.peek() === '>') { this.advance(); if (this.peek() === '>') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.UNSIGNED_RIGHT_SHIFT_ASSIGN, '>>>=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.UNSIGNED_RIGHT_SHIFT, '>>>', startLine, startColumn); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.RIGHT_SHIFT_ASSIGN, '>>=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.RIGHT_SHIFT, '>>', startLine, startColumn); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.GREATER_EQUAL, '>=', startLine, startColumn); } return this.singleCharToken(types_1.TokenType.GREATER_THAN); } handleAmpersandOperator(startLine, startColumn) { if (this.peek() === '&') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.AND_ASSIGN, '&&=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.AND, '&&', startLine, startColumn); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.BITWISE_AND_ASSIGN, '&=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.BITWISE_AND, '&', startLine, startColumn); } handlePipeOperator(startLine, startColumn) { if (this.peek() === '|') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.OR_ASSIGN, '||=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.OR, '||', startLine, startColumn); } if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.BITWISE_OR_ASSIGN, '|=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.BITWISE_OR, '|', startLine, startColumn); } handleCaretOperator(startLine, startColumn) { if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.BITWISE_XOR_ASSIGN, '^=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.BITWISE_XOR, '^', startLine, startColumn); } handleQuestionOperator(startLine, startColumn) { if (this.peek() === '?') { this.advance(); if (this.peek() === '=') { this.advance(); this.advance(); return this.createToken(types_1.TokenType.NULLISH_ASSIGN, '??=', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.NULLISH_COALESCING, '??', startLine, startColumn); } // '?.5' is a conditional followed by a number, not optional chaining if (this.peek() === '.' && !this.isDigit(this.peekNext(1))) { this.advance(); this.advance(); return this.createToken(types_1.TokenType.OPTIONAL_CHAINING, '?.', startLine, startColumn); } this.advance(); return this.createToken(types_1.TokenType.QUESTION, '?', startLine, startColumn); } /** Comment mode: the next token, which may be a comment. */ nextTokenOrComment() { this.skipWhitespace(); this.tokenStart = this.position; return this.isAtCommentStart() ? this.readComment() : this.nextToken(); } nextToken() { this.skipWhitespaceAndComments(); if (this.isAtEnd()) { return this.createToken(types_1.TokenType.EOF, ''); } const char = this.currentChar(); const startLine = this.line; const startColumn = this.column; if (char === '.' && this.isDigit(this.peek())) { return this.readNumber(startLine, startColumn); } switch (char) { case '+': return this.handlePlusOperator(); case '-': return this.handleMinusOperator(); case '*': return this.handleMultiplyOperator(); case '/': return this.handleDivideOperator(); case '%': return this.handleModuloOperator(); case '(': return this.singleCharToken(types_1.TokenType.LEFT_PAREN); case ')': return this.singleCharToken(types_1.TokenType.RIGHT_PAREN); case '{': return this.singleCharToken(types_1.TokenType.LEFT_BRACE); case '}': return this.singleCharToken(types_1.TokenType.RIGHT_BRACE); case '[': return this.singleCharToken(types_1.TokenType.LEFT_BRACKET); case ']': return this.singleCharToken(types_1.TokenType.RIGHT_BRACKET); case ';': return this.singleCharToken(types_1.TokenType.SEMICOLON); case ',': return this.singleCharToken(types_1.TokenType.COMMA); case '.': return this.handleDotOperator(); case ':': return this.singleCharToken(types_1.TokenType.COLON); case '@': return this.singleCharToken(types_1.TokenType.AT); case '\n': this.advance(); this.line++; this.column = 1; return this.createToken(types_1.TokenType.NEWLINE, '\n', startLine, startColumn); } if (char === '=') return this.handleEqualOperator(startLine, startColumn); if (char === '!') return this.handleNotOperator(startLine, startColumn); if (char === '<') return this.handleLessThanOperator(startLine, startColumn); if (char === '>') return this.handleGreaterThanOperator(startLine, startColumn); if (char === '&') return this.handleAmpersandOperator(startLine, startColumn); if (char === '|') return this.handlePipeOperator(startLine, startColumn); if (char === '^') return this.handleCaretOperator(startLine, startColumn); if (char === '?') return this.handleQuestionOperator(startLine, startColumn); if (char === '~') { this.advance(); return this.createToken(types_1.TokenType.BITWISE_NOT, '~', startLine, startColumn); } if (char === '"' || char === "'") { return this.readString(char, startLine, startColumn); } if (char === '`') { return this.readTemplateLiteral(startLine, startColumn); } if (this.isDigit(char)) { return this.readNumber(startLine, startColumn); } const codePoint = this.currentCodePoint(); if (this.isIdentifierStart(codePoint)) { return this.readIdentifier(startLine, startColumn); } return this.readPrivateName(startLine, startColumn); } /** The shebang line up to (not including) its line break. */ readShebang() { let value = ''; while (!this.isAtEnd() && !isLineTerminator(this.currentChar())) { value += this.currentCodePoint(); this.advanceCodePoint(); } return this.createToken(types_1.TokenType.SHEBANG, value, 1, 1); } singleCharToken(type) { const char = this.currentChar(); const line = this.line; const column = this.column; this.advance(); return this.createToken(type, char, line, column); } processStringEscapeSequence() { const escapeLine = this.line; const escapeColumn = this.column; this.advance(); // Skip backslash if (this.isAtEnd()) { return ''; } const escaped = this.currentChar(); this.advance(); switch (escaped) { case 'x': return this.readHexEscape(2, escapeLine, escapeColumn); case 'u': return this.readUnicodeEscape(escapeLine, escapeColumn); case '\r': // Line continuation: a backslash before a line break contributes nothing if (this.currentChar() === '\n') this.advance(); this.startNewLine(); return ''; case '\n': this.startNewLine(); return ''; default: // '\\', '\'' and '"' (like any other character) stand for themselves return Lexer.SIMPLE_ESCAPES[escaped] ?? escaped; } } readHexEscape(length, line, column) { const hex = this.input.slice(this.position, this.position + length); if (hex.length !== length || !/^[0-9a-fA-F]+$/.test(hex)) { throw this.invalidEscapeError(line, column); } for (let i = 0; i < length; i++) this.advance(); return String.fromCodePoint(Number.parseInt(hex, 16)); } readUnicodeEscape(line, column) { if (this.currentChar() !== '{') { return this.readHexEscape(4, line, column); } const close = this.input.indexOf('}', this.position); const hex = close === -1 ? '' : this.input.slice(this.position + 1, close); if (!/^[0-9a-fA-F]+$/.test(hex) || Number.parseInt(hex, 16) > 0x10ffff) { throw this.invalidEscapeError(line, column); } while (this.position <= close) this.advance(); return String.fromCodePoint(Number.parseInt(hex, 16)); } invalidEscapeError(line, column) { return new Error(`Invalid escape sequence at line ${line}, column ${column}`); } processStringCharacter() { const char = this.currentCodePoint(); const isLineBreak = char === '\n' || this.isLoneCarriageReturn(); this.advanceCodePoint(); if (isLineBreak) { this.startNewLine(); } return char; } readString(quote, startLine, startColumn) { let value = ''; this.advance(); // Skip opening quote while (!this.isAtEnd() && this.currentChar() !== quote) { if (this.currentChar() === '\\') { value += this.processStringEscapeSequence(); } else { value += this.processStringCharacter(); } } if (this.isAtEnd()) { throw new Error(`Unterminated string at line ${startLine}, column ${startColumn}`); } this.advance(); // Skip closing quote return this.createToken(types_1.TokenType.STRING, value, startLine, startColumn); } /** * Reads a template literal. The token value is the source text between the * backticks exactly as written (escapes and `${…}` included); the parser * splits it into quasis and expressions and decodes the escapes. */ readTemplateLiteral(startLine, startColumn) { const value = this.readTemplateBody(); if (this.isAtEnd()) { throw new Error(`Unterminated template literal at line ${startLine}, column ${startColumn}`); } this.advance(); // Skip closing backtick return this.createToken(types_1.TokenType.TEMPLATE_LITERAL, value, startLine, startColumn); } /** Copies template text after the opening backtick up to (not including) the closing one. */ readTemplateBody() { let value = ''; this.advance(); // Skip opening backtick while (!this.isAtEnd() && this.currentChar() !== '`') { if (this.currentChar() === '\\') { value += this.handleEscapeSequence(); } else if (this.currentChar() === '$' && this.peek() === '{') { value += this.handleInterpolation(); } else { value += this.handleRegularCharacter(); } } return value; } /** Keeps an escape sequence as written; the parser decodes it. */ handleEscapeSequence() { this.advance(); // Skip backslash if (this.isAtEnd()) return '\\'; return '\\' + this.processStringCharacter(); } /** * Copies `${…}` as written. Braces inside string literals, nested template * literals, regular expressions and comments do not count towards the closing '}'. */ handleInterpolation() { let result = '${'; this.advance(); // Skip $ this.advance(); // Skip { const start = this.position; let braceCount = 1; while (!this.isAtEnd()) { const char = this.currentChar(); const skipped = char === '/' ? this.copyCommentOrRegex(start) : undefined; if (skipped !== undefined) { result += skipped; continue; } if (char === '"' || char === "'") { result += this.copyQuotedString(char); continue; } if (char === '`') { result += '`' + this.readTemplateBody(); if (!this.isAtEnd()) { result += '`'; this.advance(); } continue; } if (char === '{') { braceCount++; } else if (char === '}') { braceCount--; if (braceCount === 0) { this.advance(); return result + '}'; } } result += this.processStringCharacter(); } return result; } /** * At a '/' inside an interpolation whose text starts at `start`: copies a * comment or a regular expression literal, or returns undefined for a division. */ copyCommentOrRegex(start) { if (this.peek() === '/' || this.peek() === '*') return this.copyComment(); const end = isRegexStartInText(this.input, this.position, start) ? regexLiteralEnd(this.input, this.position) : -1; if (end === -1) return undefined; let result = ''; while (this.position < end) result += this.processStringCharacter(); return result; } /** Copies a line comment (up to the newline) or a block comment inside an interpolation. */ copyComment() { const isBlock = this.peek() === '*'; let result = this.processStringCharacter() + this.processStringCharacter(); while (!this.isAtEnd()) { if (isBlock ? this.currentChar() === '*' && this.peek() === '/' : this.currentChar() === '\n') { break; } result += this.processStringCharacter(); } if (isBlock && !this.isAtEnd()) { result += this.processStringCharacter() + this.processStringCharacter(); } return result; } /** Copies a quoted string inside an interpolation, escapes included. */ copyQuotedString(quote) { let result = quote; this.advance(); // Skip opening quote while (!this.isAtEnd() && this.currentChar() !== quote) { if (this.currentChar() === '\\') { result += '\\'; this.advance(); if (this.isAtEnd()) break; } result += this.processStringCharacter(); } if (!this.isAtEnd()) { result += quote; this.advance(); } return result; } handleRegularCharacter() { return this.processStringCharacter(); } readNumber(startLine, startColumn) { const prefix = this.currentChar() === '0' ? this.peek().toLowerCase() : ''; const isPrefixed = prefix === 'x' || prefix === 'b' || prefix === 'o'; let value = isPrefixed ? this.readPrefixedNumber(prefix, startLine, startColumn) : this.readDecimalNumber(startLine, startColumn); if (this.currentChar() === 'n') { if (!isPrefixed && /[.eE]/.test(value)) { throw this.numberError('BigInt suffix requires an integer', startLine, startColumn); } value += 'n'; this.advance(); } if (!this.isAtEnd() && (this.isDigit(this.currentChar()) || this.isIdentifierStart(this.currentCodePoint()))) { throw this.numberError('identifier directly after number', startLine, startColumn); } return this.createToken(types_1.TokenType.NUMBER, value, startLine, startColumn); } /** Reads '0x…', '0b…' or '0o…'. */ readPrefixedNumber(prefix, startLine, startColumn) { const value = this.currentChar() + this.peek(); this.advance(); this.advance(); const digitPattern = { x: /[0-9a-fA-F]/, b: /[01]/, o: /[0-7]/ }[prefix]; const digits = this.readDigits(digitPattern, startLine, startColumn); if (digits === '') { throw this.numberError(`missing digits after 0${prefix} prefix`, startLine, startColumn); } return value + digits; } /** Reads '1', '1.5', '.5' and exponent forms such as '1.5e-3'. */ readDecimalNumber(startLine, startColumn) { let value = this.readDigits(/\d/, startLine, startColumn); if (value.length > 1 && value.startsWith('0')) { throw this.numberError('leading zero is not allowed', startLine, startColumn); } // Handle decimal numbers; in '1.5.toFixed' the second '.' is member access if (this.currentChar() === '.' && this.isDigit(this.peek())) { this.advance(); value += '.' + this.readDigits(/\d/, startLine, startColumn); } if (this.currentChar() === 'e' || this.currentChar() === 'E') { value += this.currentChar(); this.advance(); if (this.currentChar() === '+' || this.currentChar() === '-') { value += this.currentChar(); this.advance(); } const exponent = this.readDigits(/\d/, startLine, startColumn); if (exponent === '') { throw this.numberError('missing exponent digits', startLine, startColumn); } value += exponent; } return value; } /** Reads digits matching `digitPattern`, dropping '_' separators placed between digits. */ readDigits(digitPattern, startLine, startColumn) { let digits = ''; while (!this.isAtEnd()) { const char = this.currentChar(); if (digitPattern.test(char)) { digits += char; } else if (char === '_') { if (digits === '' || !digitPattern.test(this.peek())) { throw this.numberError('invalid numeric separator', startLine, startColumn); } } else { break; } this.advance(); } return digits; } numberError(reason, line, column) { return new Error(`Invalid number format at line ${line}, column ${column}: ${reason}`); } readIdentifier(startLine, startColumn) { let value = ''; while (!this.isAtEnd() && this.isIdentifierPart(this.currentCodePoint())) { value += this.currentCodePoint(); this.advanceCodePoint(); } const tokenType = this.keywords.get(value) || types_1.TokenType.IDENTIFIER; return this.createToken(tokenType, value, startLine, startColumn); } /** * `#ном`, the name of a private class member; the token value keeps the '#'. * Any other character that starts no token is an error. */ readPrivateName(startLine, startColumn) { const isPrivateName = this.currentChar() === '#' && this.isIdentifierStart(this.peekCodePoint()); if (!isPrivateName) { throw new Error(`Unexpected character '${this.currentCodePoint()}' at line ${startLine}, column ${startColumn}`); } this.advance(); // Skip '#' const name = this.readIdentifier(startLine, startColumn).value; return this.createToken(types_1.TokenType.PRIVATE_NAME, `#${name}`, startLine, startColumn); } /** The code point after the current character. */ peekCodePoint() { const code = this.input.codePointAt(this.position + 1); return code === undefined ? '' : String.fromCodePoint(code); } skipWhitespace() { while (!this.isAtEnd() && this.isWhitespace(this.currentChar()) && this.currentChar() !== '\n') { const isLineBreak = this.isLoneCarriageReturn(); this.advance(); if (isLineBreak) { this.startNewLine(); } } } isAtCommentStart() { return this.currentChar() === '/' && (this.peek() === '/' || this.peek() === '*'); } /** A comment as a `COMMENT` token whose value is its source text (comment mode). */ readComment() { const line = this.line; const column = this.column; const start = this.position; if (this.peek() === '/') { this.skipLineComment(); } else { this.skipBlockComment(); } return this.createToken(types_1.TokenType.COMMENT, this.input.slice(start, this.position), line, column); } skipWhitespaceAndComments() { this.skipWhitespace(); while (this.isAtCommentStart()) { if (this.peek() === '/') { this.skipLineComment(); } else { this.skipBlockComment(); } this.skipWhitespace(); } } skipLineComment() { // Skip the '//' this.advance(); this.advance(); // Skip until end of line while (!this.isAtEnd() && this.currentChar() !== '\n' && this.currentChar() !== '\r') { this.advanceCodePoint(); } } skipBlockComment() { const startLine = this.line; const startColumn = this.column; // Skip the '/*' this.advance(); this.advance(); while (!this.isAtEnd()) { if (this.currentChar() === '*' && this.peek() === '/') { this.advance(); this.advance(); return; } const isLineBreak = this.currentChar() === '\n' || this.isLoneCarriageReturn(); this.advanceCodePoint(); if (isLineBreak) { this.startNewLine(); } } throw new Error(`Unterminated block comment at line ${startLine}, column ${startColumn}`); } startNewLine() { this.line++; this.column = 1; } /** A '\r' not followed by '\n' is a line break on its own (old Mac line endings). */ isLoneCarriageReturn() { return this.currentChar() === '\r' && this.peek() !== '\n'; } currentChar() { return this.input[this.position]; } peek() { if (this.position + 1 >= this.input.length) return '\0'; return this.input[this.position + 1]; } /** * The full code point at the current position (both halves of a surrogate * pair). Callers check that the input has not ended. */ currentCodePoint() { return String.fromCodePoint(this.input.codePointAt(this.position)); } /** Advances past one code point, counting it as a single column (not at the end). */ advanceCodePoint() { this.position += this.currentCodePoint().length; this.column++; } advance() { if (!this.isAtEnd()) { this.position++; this.column++; } } isAtEnd() { return this.position >= this.input.length; } isDigit(char) { return char >= '0' && char <= '9'; } isIdentifierStart(char) { return /^[\p{ID_Start}$_]$/u.test(char); } isIdentifierPart(char) { return /^[\p{ID_Continue}$\u200C\u200D]$/u.test(char); } isWhitespace(char) { return char === ' ' || char === '\t' || char === '\r'; } peekNext(offset = 0) { const pos = this.position + 1 + offset; if (pos >= this.input.length) return '\0'; return this.input[pos]; } createToken(type, value, line, column) { return { type, value, line: line || this.line, column: column || this.column, }; } } exports.Lexer = Lexer; /** Words after which an operand, and so a regular expression, may follow. */ Lexer.OPERATOR_WORDS = new Set([ 'бозгашт', 'return', 'партофтан', 'throw', 'навъи', 'typeof', 'нав', 'new', 'интизор', 'await', 'void', 'delete', 'вагарна', 'чунин', 'else', 'do', 'пешфарз', ]); /** The yield operator inside a generator body, an ordinary name elsewhere. */ Lexer.YIELD_WORDS = new Set(['ҳосил', 'yield']); /** Words after which a `*` marks a generator: `функсия* г`, `ҳамзамон *г() {…}`. */ Lexer.GENERATOR_STAR_WORDS = new Set([ 'функсия', 'функция', 'function', 'ҳамзамон', 'async', 'статикӣ', 'static', 'ҷамъиятӣ', 'хосусӣ', 'муҳофизатшуда', ]); /** Binary operator words; used as ordinary names where an operand is expected. */ Lexer.INFIX_WORDS = new Set([ 'дар', 'in', 'аз', 'of', 'instanceof', ]); /** Words after which a '{' opens a block, not an object literal. */ Lexer.BLOCK_WORDS = new Set([ 'вагарна', 'чунин', 'else', 'do', ]); /** * Tokens that keep the context before them: postfix after an operand * (`а++ / 2`, the non-null assertion `а! / 2`), prefix before one * (`!/а/.test(с)`). */ Lexer.CONTEXT_KEEPING_TOKENS = new Set([ types_1.TokenType.INCREMENT, types_1.TokenType.DECREMENT, types_1.TokenType.NOT, ]); Lexer.CLOSING_BRACKETS = new Set([ types_1.TokenType.RIGHT_PAREN, types_1.TokenType.RIGHT_BRACKET, types_1.TokenType.RIGHT_BRACE, ]); /** Literal tokens: a '/' after them divides. */ Lexer.OPERAND_TOKENS = new Set([ types_1.TokenType.NUMBER, types_1.TokenType.STRING, types_1.TokenType.TEMPLATE_LITERAL, types_1.TokenType.REGEX, ]); /** Keywords whose '(' holds a condition; a '/' after the closing ')' starts a statement. */ Lexer.CONDITION_KEYWORDS = new Set([ types_1.TokenType.АГАР, types_1.TokenType.ТО, types_1.TokenType.БАРОИ, ]); Lexer.SIMPLE_ESCAPES = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', '0': '\0', }; }, {"./types":"types.js","./keyword-map":"keyword-map.js"}, ], "parser.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Parser = void 0; const types_1 = require("./types"); const lexer_1 = require("./lexer"); const import_handler_1 = require("./handlers/import-handler"); const declaration_handler_1 = require("./handlers/declaration-handler"); const loop_handler_1 = require("./handlers/loop-handler"); /** Raised when input nests deeper than the parser supports; aborts the parse. */ class NestingError extends Error { } class Parser { constructor(tokens) { this.current = 0; this.errors = []; // Nodes that were written inside parentheses. The AST has no grouping node, // but `??` mixing and `**` operand rules depend on explicit parentheses. this.parenthesized = new WeakSet(); this.depth = 0; this.patternCounter = 0; /** Inside a generator body, where `ҳосил` / `yield` is the yield operator. */ this.inGenerator = false; /** * In an ambient context (`эълон …`, the body of `эълон номфазо`/`эълон модул`): * functions and methods have no bodies and constants no initializers. */ this.ambient = false; /** Terminators the source left out, in source order (used by the formatter). */ this.omittedSemicolons = []; /** * Shorthand properties with a default (`{ а = 1 }`, after its `=`) not yet * known to be in a destructuring assignment target, the only place they * may be. Replaced, never changed, so that a failed `speculate` can restore it. */ this.coverInitializers = []; // Line breaks are insignificant: statements end with ';', so expressions // may span lines freely. this.tokens = tokens .filter(token => token.type !== types_1.TokenType.NEWLINE) .map(token => Parser.withEnglishKeyword(token)); this.importHandler = new import_handler_1.ImportHandler(this); this.declarationHandler = new declaration_handler_1.DeclarationHandler(this); this.loopHandler = new loop_handler_1.LoopHandler(this); } getErrors() { return this.errors; } static withEnglishKeyword(token) { if (token.type !== types_1.TokenType.IDENTIFIER) return token; const type = Parser.ENGLISH_KEYWORDS.get(token.value); return type ? { ...token, type } : token; } /** * `ҳамзамон`, or `async` with more on its line (as in TypeScript, a line * break after `async` makes it a name), `offset` tokens ahead. */ isAsyncWord(offset = 0) { const token = this.tokens[this.current + offset]; if (token?.type === types_1.TokenType.ҲАМЗАМОН) return true; const next = this.tokens[this.current + offset + 1]; return (token?.type === types_1.TokenType.IDENTIFIER && token.value === 'async' && next !== undefined && next.line === token.line); } /** `ҳамзамон функсия` / `async function` starts here. */ isAsyncFunctionStart() { return this.isAsyncWord() && this.peekNext()?.type === types_1.TokenType.ФУНКСИЯ; } /** `аз` or `of` between the binding and the iterable of a for-of loop. */ isOfWord(token) { return (token?.type === types_1.TokenType.АЗ || (token?.type === types_1.TokenType.IDENTIFIER && token.value === 'of')); } parse() { const body = []; this.errors = []; // Reset errors // `#!/usr/bin/env node` (the lexer only reads it on the first line) const shebang = this.match(types_1.TokenType.SHEBANG) ? this.previous().value : undefined; try { while (!this.isAtEnd()) { const stmt = this.statement(); if (stmt) { body.push(stmt); } // Don't advance here - statement() handles its own token consumption } this.checkOverloads(body); this.checkExportAssignment(body); } catch (error) { // Only nesting overflows escape statement(); they abort the whole parse this.errors.push(this.nestingErrorMessage(error)); } return { type: 'Program', body, ...(shebang !== undefined && { shebang }), line: 1, column: 1, }; } statement() { const startIndex = this.current; const covers = this.coverInitializers; try { this.enterNesting(); const parsers = [ () => this.typeScriptStatement(), () => this.contextualStatement(), () => this.importHandler.parseStatement(), () => this.declarationHandler.parseStatement(), () => this.loopHandler.parseStatement(), () => (this.match(types_1.TokenType.КӮШИШ) ? this.tryStatement() : null), () => (this.match(types_1.TokenType.ПАРТОФТАН) ? this.throwStatement() : null), () => (this.match(types_1.TokenType.АГАР) ? this.ifStatement() : null), () => (this.match(types_1.TokenType.ИНТИХОБ) ? this.switchStatement() : null), () => (this.match(types_1.TokenType.ШИКАСТАН) ? this.breakStatement() : null), () => (this.match(types_1.TokenType.ДАВОМ) ? this.continueStatement() : null), () => (this.match(types_1.TokenType.БОЗГАШТ) ? this.returnStatement() : null), () => (this.match(types_1.TokenType.LEFT_BRACE) ? this.blockStatement() : null), ]; for (const parse of parsers) { const result = parse(); if (result) { return result; } } return this.expressionStatement(); } catch (error) { // A statement that does not parse has its error already this.coverInitializers = covers; if (this.isNestingError(error)) throw error; // The parser and the lexer report problems with Errors this.errors.push(error.message); this.synchronize(startIndex); return null; } finally { this.depth--; this.reportCoverInitializers(covers); } } /** * Reports the shorthand defaults (`{ а = 1 }`) parsed since `outer` that no * destructuring assignment took: JavaScript's "Invalid shorthand property * initializer", TypeScript's TS1312. */ reportCoverInitializers(outer) { for (const { at } of this.coverInitializers.filter(entry => !outer.includes(entry))) { this.errors.push(`Invalid shorthand property initializer at line ${at.line}, column ${at.column}: '=' may follow a property name only in a destructuring assignment`); } this.coverInitializers = outer; } /** `{ а = 1 }` in a destructuring assignment target: the default of `а`, not an error. */ releaseCoverInitializers(target) { switch (target?.type) { case 'ArrayExpression': target.elements.forEach(element => this.releaseCoverInitializers(element)); break; case 'ObjectExpression': for (const property of target.properties) { if (property.type === 'SpreadElement') { this.releaseCoverInitializers(property); continue; } this.coverInitializers = this.coverInitializers.filter(entry => entry.property !== property); this.releaseCoverInitializers(property.value); } break; case 'SpreadElement': this.releaseCoverInitializers(target.argument); break; case 'AssignmentExpression': // `[а = { б = 1 }] = …`: the default is an expression, its own initializers stay this.releaseCoverInitializers(target.left); break; } } /** * Tracks syntactic nesting so that pathological input produces a positioned * parse error instead of a stack overflow. */ enterNesting() { this.depth++; if (this.depth > Parser.MAX_NESTING) { const token = this.peek(); throw new NestingError(`Nesting too deep at line ${token.line}, column ${token.column} (more than ${Parser.MAX_NESTING} levels)`); } } isNestingError(error) { return error instanceof NestingError || error instanceof RangeError; } /** Only nesting errors escape `statement()`: a NestingError or a stack overflow. */ nestingErrorMessage(error) { if (error instanceof NestingError) return error.message; const token = this.peek(); return `Nesting too deep at line ${token.line}, column ${token.column}`; } /** * `тағ х = 1;` or `тағ а = 1, б = 2;` (a VariableDeclarationList). * `allowDefinite`: false in a `барои (…; …; …)` head, where `х!` is not permitted. */ variableDeclaration(allowDefinite = true) { const kindToken = this.previous(); const kind = kindToken.type === types_1.TokenType.ТАҒЙИРЁБАНДА ? 'ТАҒЙИРЁБАНДА' : 'СОБИТ'; const declarations = [this.variableDeclarator(kind, kindToken, allowDefinite)]; while (this.match(types_1.TokenType.COMMA)) { declarations.push(this.variableDeclarator(kind, this.peek(), allowDefinite)); } this.consumeSemicolon("Expected ';' after variable declaration"); if (this.ambient) declarations.forEach(declaration => (declaration.declare = true)); if (declarations.length === 1) return declarations[0]; return { type: 'VariableDeclarationList', kind, declarations, ...(this.ambient && { declare: true }), line: kindToken.line, column: kindToken.column, }; } /** One `ном: Т = қимат` of a declaration; `start` is where it begins (its `тағ` for the first). */ variableDeclarator(kind, start, allowDefinite) { // Parse pattern (identifier, array destructuring, or object destructuring) const identifier = this.parsePattern(); // Definite assignment assertion: `тағ х!: рақам;` const definite = identifier.type === 'Identifier' && this.check(types_1.TokenType.NOT) && !this.hasLineBreakBefore() ? this.advance() : undefined; // Parse optional type annotation let typeAnnotation; if (this.match(types_1.TokenType.COLON)) { typeAnnotation = this.typeAnnotation(); } let init; if (this.match(types_1.TokenType.ASSIGN)) { init = this.assignment(); if (this.ambient) this.checkAmbientInitializer(kind, init); } else if (kind === 'СОБИТ' && !this.ambient) { throw new Error(`Missing initializer in constant declaration at line ${start.line}, column ${start.column}`); } if (definite) { this.checkDefiniteAssignment(definite, Boolean(init), Boolean(typeAnnotation), allowDefinite); } return { type: 'VariableDeclaration', kind, identifier, typeAnnotation, init, ...(definite && { definite: true }), line: start.line, column: start.column, }; } /** * TypeScript's rules for a definite assignment assertion (`х!: Т`): it needs * a type annotation and no initializer, and only some declarations allow it. */ checkDefiniteAssignment(bang, hasInitializer, hasType, permitted) { let problem; if (hasInitializer) { problem = 'Declarations with initializers cannot also have definite assignment assertions'; } else if (!hasType) { problem = 'Declarations with definite assignment assertions must also have type annotations'; } else if (!permitted) { problem = "A definite assignment assertion '!' is not permitted in this context"; } // The declaration itself is well-formed: report and keep parsing if (problem) { this.errors.push(`${problem} at line ${bang.line}, column ${bang.column}`); } } /** * `функсия ном(…) { … }`; without a body (`функсия ном(х: рақам): рақам;`) * an overload signature or, in an ambient context, a declared function. */ functionDeclaration() { const funcToken = this.previous(); const generator = this.match(types_1.TokenType.MULTIPLY); let name; if (this.check(types_1.TokenType.IDENTIFIER)) { name = this.advance(); } else if (this.matchBuiltinIdentifier()) { name = this.previous(); } else { throw new Error(`Expected function name at line ${this.peek().line}, column ${this.peek().column}`); } // Generic type parameters: `<Т>`, `<Т мерос { дарозӣ: рақам } = сатр>` const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after function name"); const { params, thisType } = this.withGenerator(false, () => this.parseParametersWithThis("Expected ')' after parameters")); // Parse optional return type let returnType; if (this.match(types_1.TokenType.COLON)) { returnType = this.returnTypeAnnotation(); } const identifier = { type: 'Identifier', name: name.value, line: name.line, column: name.column, }; if (this.isSignatureEnd()) { this.consumeSemicolon("Expected '{' before function body"); return { type: 'FunctionSignature', name: identifier, ...(typeParameters && { typeParameters }), params, ...(returnType && { returnType }), ...(thisType && { thisType }), ...(generator && { generator }), ...(this.ambient && { declare: true }), line: funcToken.line, column: funcToken.column, }; } this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' before function body"); if (this.ambient) this.reportImplementationInAmbientContext(funcToken); const body = this.withGenerator(generator, () => this.blockStatement()); return { type: 'FunctionDeclaration', name: identifier, ...(typeParameters && { typeParameters }), params, returnType, body, ...(generator && { generator }), ...(thisType && { thisType }), line: funcToken.line, column: funcToken.column, }; } /** * Whether a function or method signature ends here without a body: at ';', * '}', the end of input or a line break (anything else must be its body). */ isSignatureEnd() { return (this.check(types_1.TokenType.SEMICOLON) || this.check(types_1.TokenType.RIGHT_BRACE) || this.isAtEnd() || (this.hasLineBreakBefore() && !this.check(types_1.TokenType.LEFT_BRACE))); } /** TypeScript's "An implementation cannot be declared in ambient contexts" (TS1183). */ reportImplementationInAmbientContext(at) { this.errors.push(`An implementation cannot be declared in ambient contexts at line ${at.line}, column ${at.column}`); } /** * Parses a function's parameters or body: `ҳосил` is the yield operator in * a generator body and an ordinary name everywhere else. */ withGenerator(generator, parse) { const outer = this.inGenerator; this.inGenerator = generator; try { return parse(); } finally { this.inGenerator = outer; } } isYieldKeyword(token) { return (this.inGenerator && token.type === types_1.TokenType.IDENTIFIER && Parser.YIELD_KEYWORDS.has(token.value)); } /** `ҳосил`, `ҳосил х`, `ҳосил* итерабел`; binds as loosely as an assignment. */ yieldExpression() { const yieldToken = this.advance(); let delegate = false; let argument; // As in JavaScript, a line break right after 'ҳосил' ends it if (!this.hasLineBreakBefore()) { delegate = this.match(types_1.TokenType.MULTIPLY); if (delegate || !Parser.YIELD_TERMINATORS.has(this.peek().type)) { argument = this.assignment(); } } return { type: 'YieldExpression', ...(argument && { argument }), delegate, line: yieldToken.line, column: yieldToken.column, }; } blockStatement() { const leftBrace = this.previous(); const body = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const stmt = this.statement(); if (stmt) { body.push(stmt); } } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after block"); this.checkOverloads(body); return { type: 'BlockStatement', body, line: leftBrace.line, column: leftBrace.column, }; } ifStatement() { const ifToken = this.previous(); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'агар'"); const test = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after if condition"); const consequent = this.statement(); let alternate; if (this.match(types_1.TokenType.ВАГАРНА, types_1.TokenType.ЧУНИН)) { alternate = this.statement(); } return { type: 'IfStatement', test, consequent, alternate, line: ifToken.line, column: ifToken.column, }; } whileStatement() { const whileToken = this.previous(); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'то'"); const test = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after while condition"); const body = this.statement(); return { type: 'WhileStatement', test, body, line: whileToken.line, column: whileToken.column, }; } /** * Statements started by punctuation or by a contextual word: `;`, a label, * `кун { … } то (…);`, `debugger;` and enums. `кун` and `шумориш` are * keywords only in this position, so they remain usable as names elsewhere. */ contextualStatement() { const token = this.peek(); const next = this.peekNext(); if (token.type === types_1.TokenType.SEMICOLON) { this.advance(); return { type: 'EmptyStatement', line: token.line, column: token.column }; } if (next?.type === types_1.TokenType.COLON && this.isPlainIdentifierToken(token)) { return this.labeledStatement(); } if (token.type === types_1.TokenType.СОБИТ && this.isEnumStart(1)) { this.advance(); return this.enumDeclaration(token, true); } if (this.isEnumStart(0)) { return this.enumDeclaration(token, false); } if (token.type !== types_1.TokenType.IDENTIFIER) return null; if (Parser.DO_KEYWORDS.has(token.value) && next?.type === types_1.TokenType.LEFT_BRACE) { return this.doWhileStatement(); } if (token.value === 'debugger') { this.advance(); this.consumeSemicolon("Expected ';' after 'debugger'"); return { type: 'DebuggerStatement', line: token.line, column: token.column, }; } return null; } // --------------------------------------------------------------------------- // TypeScript declarations: decorators, `эълон`, `истифода`, overloads // --------------------------------------------------------------------------- /** `@ном`, `@а.б(1)`, `@(ифода)`: the decorators before a class, member or parameter. */ parseDecorators() { const decorators = []; while (this.match(types_1.TokenType.AT)) { const at = this.previous(); decorators.push({ type: 'Decorator', expression: this.decoratorExpression(), line: at.line, column: at.column, }); } return decorators; } /** * As in TypeScript: a name with member accesses and at most one call * (`@а.б<Т>(1)`), or any expression in parentheses (`@(а[0])`). */ decoratorExpression() { if (this.match(types_1.TokenType.LEFT_PAREN)) { const expression = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after decorator expression"); this.parenthesized.add(expression); return expression; } let expression = this.parseIdentifierExpression(); if (!expression) { throw new Error(this.unexpectedTokenMessage("Expected decorator name after '@'")); } while (this.match(types_1.TokenType.DOT)) { expression = this.createMemberExpression(expression, this.parsePropertyName("Expected property name after '.'"), false); } const typeArguments = this.parseTypeArgumentsInExpression(); if (this.match(types_1.TokenType.LEFT_PAREN)) { expression = this.finishCall(expression, typeArguments); } else if (typeArguments) { expression = this.createInstantiation(expression, typeArguments); } return expression; } /** * Statements of TypeScript declarations started by `@`, `эълон`, * `истифода` or `интизор истифода`; null for any other statement. The * words are keywords only here, so they remain usable as names elsewhere. */ typeScriptStatement() { const token = this.peek(); let statement; if (token.type === types_1.TokenType.AT) { statement = this.decoratedStatement(); } else if (this.isAmbientStart()) { statement = this.ambientDeclaration(); } else if (this.isUsingStart(0)) { return this.usingDeclaration(false); } else if (token.type === types_1.TokenType.ИНТИЗОР && this.isUsingStart(1)) { return this.usingDeclaration(true); } else { return null; } // A statement that failed to parse (its error is recorded) leaves nothing return (statement ?? { type: 'EmptyStatement', line: token.line, column: token.column }); } /** * `@д синф К {}`, also before `мавҳум синф` and `содир [пешфарз]` * (`@д содир синф К {}`, like `содир @д синф К {}`). */ decoratedStatement() { const decorators = this.parseDecorators(); return this.decorate(decorators, this.statement()); } /** * Gives `decorators` to the class `statement` declares (also when it * exports it, `содир [пешфарз] синф`, or a class expression as the default * export); anywhere else they are an error. */ decorate(decorators, statement) { let target = statement?.type === 'ExportDeclaration' ? statement.declaration : statement; if (target?.type === 'ExpressionStatement') { target = target.expression; } const isClass = target?.type === 'ClassExpression' || (target?.type === 'ClassDeclaration' && !target.declare); if (!isClass) { this.reportInvalidDecorators(decorators); return statement; } const classNode = target; classNode.decorators = [...decorators, ...(classNode.decorators ?? [])]; return statement; } /** * `эълон` (or `declare`) followed, on its line, by a declaration: then it * starts an ambient declaration. Anywhere else it is an ordinary name. */ isAmbientStart() { const token = this.peek(); const next = this.peekNext(); if (token.type !== types_1.TokenType.IDENTIFIER || !Parser.DECLARE_KEYWORDS.has(token.value) || !next || next.line !== token.line) { return false; } if (Parser.AMBIENT_DECLARATION_TOKENS.has(next.type)) return true; if (next.type !== types_1.TokenType.IDENTIFIER) return false; const after = this.tokens[this.current + 2]; if (Parser.MODULE_KEYWORDS.has(next.value)) { return after?.type === types_1.TokenType.STRING || after?.type === types_1.TokenType.IDENTIFIER; } if (Parser.GLOBAL_KEYWORDS.has(next.value)) return after?.type === types_1.TokenType.LEFT_BRACE; return this.isEnumStart(1); } /** * `эълон собит х: рақам;`, `эълон функсия ф(): Т;`, `эълон синф К { … }`, * `эълон шумориш`, `эълон номфазо`, `эълон модул "ном" { … }`, * `эълон глобалӣ { … }`: declarations of things that exist at run time * elsewhere. They give the type checker types and are erased in the output. */ ambientDeclaration() { const declareToken = this.advance(); const outer = this.ambient; this.ambient = true; try { const keyword = this.peek(); if (keyword.type === types_1.TokenType.IDENTIFIER && Parser.MODULE_KEYWORDS.has(keyword.value)) { this.advance(); if (this.check(types_1.TokenType.STRING)) { return this.ambientModule(declareToken, this.advance()); } // `эълон модул Ном { … }`: the older spelling of `эълон номфазо Ном { … }` return this.namespaceDeclaration(); } if (keyword.type === types_1.TokenType.IDENTIFIER && Parser.GLOBAL_KEYWORDS.has(keyword.value)) { this.advance(); return this.ambientModule(declareToken, undefined); } return this.statement(); } finally { this.ambient = outer; } } /** The body of `эълон модул "ном" { … }` or `эълон глобалӣ { … }`. */ ambientModule(declareToken, name) { this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after module name"); const body = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const statement = this.statement(); if (statement) body.push(statement); } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after module body"); return { type: 'AmbientModuleDeclaration', ...(name ? { name: this.createLiteral(name.value, name) } : { global: true }), body, line: declareToken.line, column: declareToken.column, }; } /** * Only a `собит` may have an initializer in an ambient context, and only a * literal one: TypeScript's TS1039 / TS1254. */ checkAmbientInitializer(kind, init) { let literal = init; if (literal.type === 'UnaryExpression' && literal.operator === '-') { literal = literal.argument; } const isLiteral = literal.type === 'Literal' || (literal.type === 'TemplateLiteral' && literal.expressions.length === 0); if (kind === 'СОБИТ' && isLiteral) return; this.errors.push(`Initializers are not allowed in ambient contexts at line ${init.line}, column ${init.column}`); } /** `истифода ном =` / `истифода ном:` starts `offset` tokens ahead, on one line. */ isUsingStart(offset) { const keyword = this.tokens[this.current + offset]; const name = this.tokens[this.current + offset + 1]; const after = this.tokens[this.current + offset + 2]?.type; return (keyword?.type === types_1.TokenType.IDENTIFIER && Parser.USING_KEYWORDS.has(keyword.value) && name !== undefined && name.line === keyword.line && this.isPlainIdentifierToken(name) && (after === types_1.TokenType.ASSIGN || after === types_1.TokenType.COLON)); } /** * `истифода манбаъ = кушодан();` (TypeScript `using`) and * `интизор истифода манбаъ = …;` (`await using`): constants whose value is * disposed of (`[Symbol.dispose]()` / `[Symbol.asyncDispose]()`) when the * block ends. */ usingDeclaration(isAwait) { const start = this.advance(); if (isAwait) this.advance(); // 'истифода' const declarations = [this.variableDeclarator('СОБИТ', start, false)]; while (this.match(types_1.TokenType.COMMA)) { declarations.push(this.variableDeclarator('СОБИТ', this.peek(), false)); } this.consumeSemicolon("Expected ';' after variable declaration"); const using = isAwait ? 'async' : 'sync'; for (const declaration of declarations) { declaration.using = using; if (declaration.identifier.type !== 'Identifier') { this.errors.push(`'истифода' declarations may not have binding patterns at line ${declaration.line}, column ${declaration.column}`); } } if (declarations.length === 1) return declarations[0]; return { type: 'VariableDeclarationList', kind: 'СОБИТ', declarations, using, line: start.line, column: start.column, }; } /** * Each overload signature (`функсия ф(х: рақам): рақам;`) of a statement * list must be followed by another one or by the implementation, as in * TypeScript. */ checkOverloads(statements) { statements.forEach((statement, index) => { const signature = this.unwrapExported(statement); if (signature.type !== 'FunctionSignature' || signature.declare) return; const next = statements[index + 1] && this.unwrapExported(statements[index + 1]); const continues = (next?.type === 'FunctionSignature' || next?.type === 'FunctionDeclaration') && next.name.name === signature.name.name; if (!continues) { this.errors.push(`Function implementation is missing or not immediately following the declaration at line ${signature.line}, column ${signature.column}`); } }); } /** `содир = х;` must be the module's only export (TypeScript's TS2309). */ checkExportAssignment(statements) { const assignment = statements.find(statement => statement.type === 'ExportAssignment'); const otherExport = statements.some(statement => statement.type === 'ExportDeclaration' && statement.exportKind !== 'type' && !['InterfaceDeclaration', 'TypeAlias'].includes(statement.declaration?.type ?? '')); if (assignment && otherExport) { this.errors.push(`An export assignment cannot be used in a module with other exported elements at line ${assignment.line}, column ${assignment.column}`); } } unwrapExported(statement) { return statement.type === 'ExportDeclaration' ? (statement.declaration ?? statement) : statement; } doWhileStatement() { const doToken = this.advance(); this.consume(types_1.TokenType.LEFT_BRACE, `Expected '{' after '${doToken.value}'`); const body = this.blockStatement(); this.consume(types_1.TokenType.ТО, `Expected 'то' after the body of '${doToken.value}'`); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'то'"); const test = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after do-while condition"); // As in JavaScript, the ';' after the condition may be left out if (!this.match(types_1.TokenType.SEMICOLON)) this.noteOmittedSemicolon(); return { type: 'DoWhileStatement', body, test, line: doToken.line, column: doToken.column, }; } labeledStatement() { const label = this.createIdentifier(this.advance()); this.advance(); // ':' const body = this.statement(); if (body && Parser.DECLARATION_TYPES.has(body.type)) { this.errors.push(`A declaration cannot be labeled at line ${body.line}, column ${body.column} (label '${label.name}')`); } return { type: 'LabeledStatement', label, body, line: label.line, column: label.column, }; } /** `шумориш Ном {` (or `enum Ном {`) starts `offset` tokens ahead. */ isEnumStart(offset) { const keyword = this.tokens[this.current + offset]; const name = this.tokens[this.current + offset + 1]; return (keyword?.type === types_1.TokenType.IDENTIFIER && Parser.ENUM_KEYWORDS.has(keyword.value) && name !== undefined && this.isPlainIdentifierToken(name) && this.tokens[this.current + offset + 2]?.type === types_1.TokenType.LEFT_BRACE); } /** `шумориш Ранг { Сурх, Сабз = 5, "номи дароз" = "х" }`, at the `шумориш` token. */ enumDeclaration(startToken, isConst) { this.advance(); // 'шумориш' / 'enum' const name = this.createIdentifier(this.advance()); this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after enum name"); const members = []; const names = new Set(); while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const member = this.enumMember(); const memberName = member.id.type === 'Identifier' ? member.id.name : String(member.id.value); if (names.has(memberName)) { throw new Error(`Duplicate enum member '${memberName}' at line ${member.line}, column ${member.column}`); } names.add(memberName); members.push(member); if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after enum members"); return { type: 'EnumDeclaration', name, members, ...(isConst && { const: true }), ...(this.ambient && { declare: true }), line: startToken.line, column: startToken.column, }; } enumMember() { const token = this.peek(); let id; if (this.match(types_1.TokenType.STRING)) { id = this.createLiteral(token.value, token); } else if (this.match(types_1.TokenType.LEFT_BRACKET)) { id = this.computedEnumMemberName(); } else if (this.isIdentifierNameToken(token)) { id = this.createIdentifier(this.advance()); } else { throw new Error(this.unexpectedTokenMessage('Expected enum member name')); } const initializer = this.match(types_1.TokenType.ASSIGN) ? this.assignment() : undefined; return { type: 'EnumMember', id, ...(initializer && { initializer }), line: token.line, column: token.column, }; } /** * `["номи дароз"]` and `` [`ном`] `` name enum members, as in TypeScript; * any other computed name is TypeScript's error TS1164. After the `[`. */ computedEnumMemberName() { const token = this.peek(); let name; if (this.match(types_1.TokenType.STRING)) { name = token.value; } else if (this.check(types_1.TokenType.TEMPLATE_LITERAL) && !token.value.includes('${')) { name = this.cookTemplateText(this.advance().value, token); } else { this.assignment(); this.errors.push(`Computed property names are not allowed in enums at line ${token.line}, column ${token.column}`); } this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after the enum member name"); return this.createLiteral(name ?? '', token); } forStatement() { const forToken = this.previous(); // `барои интизор (собит х аз …)`: for await const isAwait = this.match(types_1.TokenType.ИНТИЗОР); this.consume(types_1.TokenType.LEFT_PAREN, isAwait ? "Expected '(' after 'барои интизор'" : "Expected '(' after 'барои'"); const savedIndex = this.current; const loopType = this.detectForLoopType(); let loop; if (loopType.isForOf || loopType.isForIn) { loop = this.parseForOfOrForInLoop(forToken, loopType.isForOf); } else { this.current = savedIndex; loop = this.parseForInOfAssignment(forToken) ?? this.parseTraditionalForLoop(forToken); } if (isAwait && loop.type === 'ForOfStatement') { loop.await = true; } else if (isAwait) { this.errors.push(`'барои интизор' needs a for-of loop ('аз') at line ${forToken.line}, column ${forToken.column}`); } return loop; } /** * `барои (х аз …)`, `барои (о.а дар …)`, `барои ([а, б] аз …)`: a for-of or * for-in loop that assigns to an existing variable, property or pattern. * Null when the head is that of a `барои (…; …; …)` loop. */ parseForInOfAssignment(forToken) { if (this.check(types_1.TokenType.SEMICOLON) || this.check(types_1.TokenType.ТАҒЙИРЁБАНДА)) return null; const head = this.speculate(() => { const left = this.call(); const isForOf = this.isOfWord(this.peek()); if (!isForOf && !this.check(types_1.TokenType.ДАР)) return undefined; return { left, isForOf, keyword: this.advance() }; }); if (!head) return null; if (!this.isAssignmentTarget(head.left, true)) { throw new Error(`Invalid left-hand side in a for-${head.isForOf ? 'of' : 'in'} loop at line ${head.left.line}, column ${head.left.column}`); } this.releaseCoverInitializers(head.left); const right = head.isForOf ? this.assignment() : this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after for-of/for-in clauses"); const body = this.statement(); return { type: head.isForOf ? 'ForOfStatement' : 'ForInStatement', left: head.left, right, body, line: forToken.line, column: forToken.column, }; } detectForLoopType() { let lookaheadIndex = this.current; let isForOf = false; let isForIn = false; // `барои (истифода х аз …)`, `барои интизор (интизор истифода х аз …)` const usingOffset = this.check(types_1.TokenType.ИНТИЗОР) ? 1 : 0; if (this.isUsingWord(this.tokens[lookaheadIndex + usingOffset]) && this.isOfWord(this.tokens[lookaheadIndex + usingOffset + 2])) { return { isForOf: true, isForIn: false }; } if (this.tokens[lookaheadIndex]?.type === types_1.TokenType.ТАҒЙИРЁБАНДА || this.tokens[lookaheadIndex]?.type === types_1.TokenType.СОБИТ) { lookaheadIndex++; const nextToken = this.tokens[lookaheadIndex]; let afterBinding = -1; if (this.isTypeKeywordOrIdentifier(nextToken?.type)) { afterBinding = lookaheadIndex + 1; } else if (this.isPatternStart(nextToken?.type)) { // `[к, в]` / `{ а, б }`: skip the whole pattern, defaults included const close = this.findMatchingBracket(lookaheadIndex); if (close !== -1) afterBinding = close + 1; } const keyword = afterBinding === -1 ? undefined : this.tokens[afterBinding]; isForOf = this.isOfWord(keyword); isForIn = keyword?.type === types_1.TokenType.ДАР; } return { isForOf, isForIn }; } isPatternStart(type) { return type === types_1.TokenType.LEFT_BRACKET || type === types_1.TokenType.LEFT_BRACE; } /** Index of the bracket closing the `(`, `[` or `{` at `openIndex`, or -1. */ findMatchingBracket(openIndex) { let depth = 0; for (let i = openIndex; i < this.tokens.length; i++) { switch (this.tokens[i].type) { case types_1.TokenType.LEFT_PAREN: case types_1.TokenType.LEFT_BRACKET: case types_1.TokenType.LEFT_BRACE: depth++; break; case types_1.TokenType.RIGHT_PAREN: case types_1.TokenType.RIGHT_BRACKET: case types_1.TokenType.RIGHT_BRACE: if (--depth === 0) return i; break; } } return -1; } isTypeKeywordOrIdentifier(type) { return (type === types_1.TokenType.IDENTIFIER || type === types_1.TokenType.РАҚАМ || type === types_1.TokenType.САТР || type === types_1.TokenType.МАНТИҚӢ); } isUsingWord(token) { return token?.type === types_1.TokenType.IDENTIFIER && Parser.USING_KEYWORDS.has(token.value); } parseForOfOrForInLoop(forToken, isForOf) { const awaitUsing = this.check(types_1.TokenType.ИНТИЗОР); if (awaitUsing) this.advance(); const varToken = this.advance(); const using = this.isUsingWord(varToken) ? (awaitUsing ? 'async' : 'sync') : undefined; const kind = varToken.type === types_1.TokenType.ТАҒЙИРЁБАНДА ? 'ТАҒЙИРЁБАНДА' : 'СОБИТ'; let id; if (this.isPatternStart(this.peek().type)) { // Destructuring, as in a declaration: `[к, в = 0]`, `{ а, ...боқӣ }` id = this.parsePattern(); } else { const nameToken = this.isTypeKeywordOrIdentifier(this.peek().type) ? this.advance() : this.consume(types_1.TokenType.IDENTIFIER, 'Expected variable name'); id = { type: 'Identifier', name: nameToken.value, line: nameToken.line, column: nameToken.column, }; } if (isForOf) { // `аз`, which detectForLoopType found after the binding this.advance(); } else { this.consume(types_1.TokenType.ДАР, "Expected 'дар' in for-in loop"); } const right = this.assignment(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after for-of/for-in clauses"); const body = this.statement(); const left = { type: 'VariableDeclaration', kind, identifier: id, init: undefined, ...(using && { using }), line: id.line, column: id.column, }; return { type: isForOf ? 'ForOfStatement' : 'ForInStatement', left, right, body, line: forToken.line, column: forToken.column, }; } parseTraditionalForLoop(forToken) { let init = null; if (this.match(types_1.TokenType.ТАҒЙИРЁБАНДА, types_1.TokenType.СОБИТ)) { // `барои (тағ и = 0, ҷ = н - 1; …)` init = this.variableDeclaration(false); } else if (!this.check(types_1.TokenType.SEMICOLON)) { init = this.expressionStatement(); } if (init && init.type === 'ExpressionStatement') { // ExpressionStatement already consumed the semicolon } else if (!init) { this.consume(types_1.TokenType.SEMICOLON, "Expected ';' after for loop initializer"); } let test = null; if (!this.check(types_1.TokenType.SEMICOLON)) { test = this.expression(); } this.consume(types_1.TokenType.SEMICOLON, "Expected ';' after for loop condition"); let update = null; if (!this.check(types_1.TokenType.RIGHT_PAREN)) { update = this.expression(); } this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after for clauses"); const body = this.statement(); return { type: 'ForStatement', init, test, update, body, line: forToken.line, column: forToken.column, }; } returnStatement() { const returnToken = this.previous(); // As in JavaScript, a line break right after 'бозгашт' ends the statement let argument; if (!this.check(types_1.TokenType.SEMICOLON) && !this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd() && !this.hasLineBreakBefore()) { argument = this.expression(); } this.consumeSemicolon("Expected ';' after return value"); return { type: 'ReturnStatement', argument, line: returnToken.line, column: returnToken.column, }; } expressionStatement() { const expr = this.expression(); this.consumeSemicolon("Expected ';' after expression"); return { type: 'ExpressionStatement', expression: expr, line: expr.line, column: expr.column, }; } /** Full expression, including the comma operator: `а++, б--`. */ expression() { const expr = this.assignment(); if (!this.check(types_1.TokenType.COMMA)) { return expr; } const expressions = [expr]; while (this.match(types_1.TokenType.COMMA)) { expressions.push(this.assignment()); } return { type: 'SequenceExpression', expressions, line: expr.line, column: expr.column, }; } assignment() { try { this.enterNesting(); if (this.isYieldKeyword(this.peek())) { return this.yieldExpression(); } const arrowFunc = this.tryParseArrowFunction(); if (arrowFunc) { return arrowFunc; } const expr = this.conditional(); if (this.match(...Parser.ASSIGNMENT_OPERATORS)) { const operator = this.previous(); if (!this.isAssignmentTarget(expr, operator.type === types_1.TokenType.ASSIGN)) { throw new Error(`Invalid left-hand side in assignment at line ${operator.line}, column ${operator.column}`); } this.releaseCoverInitializers(expr); const value = this.assignment(); return { type: 'AssignmentExpression', left: expr, operator: operator.value, right: value, line: expr.line, column: expr.column, }; } return expr; } finally { this.depth--; } } /** * Whether `expr` may be assigned to: a variable or a (non-optional) member * and, for plain `=`, an array/object literal read as a destructuring * pattern whose elements are targets themselves. */ isAssignmentTarget(expr, allowPattern) { switch (expr.type) { case 'Identifier': return true; case 'MemberExpression': return !expr.optional; case 'NonNullExpression': case 'AsExpression': case 'TypeAssertion': // `х! = 1`, `(х чун ҳар) = 1`: the assertion is erased return this.isAssignmentTarget(expr.expression, false); case 'ArrayExpression': return (allowPattern && !this.parenthesized.has(expr) && expr.elements.every(element => !element || this.isPatternElement(element))); case 'ObjectExpression': return (allowPattern && !this.parenthesized.has(expr) && expr.properties.every(property => property.type === 'SpreadElement' ? this.isPatternElement(property) : !property.method && this.isPatternElement(property.value))); default: return false; } } /** An element of a destructuring assignment: a target, `...target` or `target = default`. */ isPatternElement(element) { if (element.type === 'SpreadElement') { return this.isAssignmentTarget(element.argument, true); } if (element.type === 'AssignmentExpression') { const assignment = element; return assignment.operator === '=' && !this.parenthesized.has(element); } return this.isAssignmentTarget(element, true); } checkUpdateOperand(argument, operator) { if (!this.isAssignmentTarget(argument, false)) { throw new Error(`Invalid operand for '${operator.value}' at line ${operator.line}, column ${operator.column}; expected a variable or property`); } } /** * Parses an arrow function if one starts here: `х => …`, `(а, б = 1, ...в) => …`, * `({ а }): рақам => …`, optionally prefixed with `ҳамзамон`. Returns null otherwise. */ tryParseArrowFunction() { const startToken = this.peek(); const offset = this.isAsyncArrowStart() ? 1 : 0; // The token after an async arrow's `ҳамзамон` exists: isAsyncArrowStart looked at it const head = this.tokens[this.current + offset]; let params; let returnType; let typeParameters; if (head.type === types_1.TokenType.LESS_THAN) { const generic = this.tryParseGenericArrowHead(offset); if (!generic) return null; ({ typeParameters, params, returnType } = generic); } else if (this.isPlainIdentifierToken(head) && this.tokens[this.current + offset + 1]?.type === types_1.TokenType.ARROW) { // Single parameter without parentheses this.current += offset; const identifier = this.createIdentifier(this.advance()); this.advance(); // consume '=>' params = [ { type: 'Parameter', name: identifier, line: identifier.line, column: identifier.column, }, ]; } else if (head.type === types_1.TokenType.LEFT_PAREN) { const close = this.findMatchingParen(this.current + offset); const after = close >= 0 ? this.tokens[close + 1]?.type : undefined; if (after === types_1.TokenType.ARROW) { this.current += offset + 1; // consume [ҳамзамон] '(' params = this.withGenerator(false, () => this.parseParameterList("Expected ')' after arrow function parameters")); this.consume(types_1.TokenType.ARROW, "Expected '=>' after arrow function parameters"); } else if (after === types_1.TokenType.COLON) { // `(…): Т => …` or a parenthesized conditional branch `а ? (б) : в` const head = this.speculate(() => { this.current += offset + 1; const list = this.withGenerator(false, () => this.parseParameterList("Expected ')' after arrow function parameters")); this.consume(types_1.TokenType.COLON, "Expected ':' before return type"); const type = this.returnTypeAnnotation(); this.consume(types_1.TokenType.ARROW, "Expected '=>' after return type"); return { list, type }; }); if (!head) return null; params = head.list; returnType = head.type; } else { return null; } } else { return null; } // An arrow function is never a generator, even inside one const body = this.withGenerator(false, () => this.parseArrowFunctionBody()); const arrow = { type: 'ArrowFunctionExpression', params, body, returnType, line: startToken.line, column: startToken.column, }; if (offset) arrow.isAsync = true; if (typeParameters) arrow.typeParameters = typeParameters; return arrow; } /** * `ҳамзамон` / `async` before the parameters of an arrow function. `async` * alone is a name: `async => 1`, `async(1)` (a call when no `=>` follows). */ isAsyncArrowStart() { const next = this.peekNext(); if (!this.isAsyncWord() || !next) return false; if (this.check(types_1.TokenType.ҲАМЗАМОН)) return true; return (next.type === types_1.TokenType.LEFT_PAREN || next.type === types_1.TokenType.LESS_THAN || (this.isPlainIdentifierToken(next) && this.tokens[this.current + 2]?.type === types_1.TokenType.ARROW)); } /** * Head of a generic arrow function, `<Т, К мерос сатр,>(х: Т): К =>`, up to * and including '=>'. As in TypeScript (.ts files), a '<' that starts an * expression begins one when a name follows and the rest parses as an arrow * head; otherwise it is the type assertion `<Т>х` (see `unary`), and * nothing is consumed here. */ tryParseGenericArrowHead(offset) { const name = this.tokens[this.current + offset + 1]; const afterName = this.tokens[this.current + offset + 2]; // `<собит Т>(х: Т) => х`: a modifier before the first name const modified = name !== undefined && this.typeParameterModifier(name) !== undefined && afterName !== undefined && this.startsTypeParameter(afterName); if (!name || (!this.isPlainIdentifierToken(name) && !modified)) return null; return this.speculate(() => { this.current += offset; const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after type parameters"); const params = this.parseParameterList("Expected ')' after arrow function parameters"); const returnType = this.match(types_1.TokenType.COLON) ? this.returnTypeAnnotation() : undefined; this.consume(types_1.TokenType.ARROW, "Expected '=>' after arrow function parameters"); return { typeParameters, params, returnType }; }); } /** Index of the ')' matching the '(' at `openIndex`, or -1. */ findMatchingParen(openIndex) { let depth = 0; for (let i = openIndex; i < this.tokens.length; i++) { const type = this.tokens[i].type; if (type === types_1.TokenType.LEFT_PAREN) depth++; else if (type === types_1.TokenType.RIGHT_PAREN && --depth === 0) return i; } return -1; } /** * Runs `parse`; when it throws or returns undefined, restores the position, * the errors, the omitted semicolons, the pending shorthand defaults and * every `>>` it split (see `consumeTypeArgumentsClose`), and returns null. */ speculate(parse) { const savedIndex = this.current; const savedErrors = this.errors.length; const savedOmitted = this.omittedSemicolons.length; const savedCovers = this.coverInitializers; const outerSplits = this.tokenSplits; const splits = []; this.tokenSplits = splits; let result; try { result = parse(); } catch (error) { if (this.isNestingError(error)) throw error; result = undefined; } finally { this.tokenSplits = outerSplits; } if (result !== undefined) { outerSplits?.push(...splits); return result; } for (const split of splits.reverse()) this.tokens.splice(split.index, 2, split.token); this.current = savedIndex; this.errors.length = savedErrors; this.omittedSemicolons.length = savedOmitted; this.coverInitializers = savedCovers; return null; } /** Like `speculate`, but an error `parse` records also makes it fail. */ speculateCleanly(parse) { return this.speculate(() => { const errorCount = this.errors.length; const result = parse(); return this.errors.length === errorCount ? result : undefined; }); } parseArrowFunctionBody() { if (this.match(types_1.TokenType.LEFT_BRACE)) { return this.blockStatement(); } // Expression body return this.assignment(); } conditional() { const test = this.coalesce(); if (!this.match(types_1.TokenType.QUESTION)) { return test; } const consequent = this.assignment(); this.consume(types_1.TokenType.COLON, "Expected ':' in conditional expression"); const alternate = this.assignment(); return { type: 'ConditionalExpression', test, consequent, alternate, line: test.line, column: test.column, }; } /** `а ?? б`; mixing with unparenthesized `&&`/`||` is a syntax error, as in JavaScript. */ coalesce() { let expr = this.or(); if (!this.check(types_1.TokenType.NULLISH_COALESCING)) { return expr; } if (this.isUnparenthesizedLogical(expr)) { throw new Error(this.nullishMixingMessage()); } while (this.match(types_1.TokenType.NULLISH_COALESCING)) { const operator = this.previous(); const right = this.bitwiseOr(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } if (this.check(types_1.TokenType.OR) || this.check(types_1.TokenType.AND)) { throw new Error(this.nullishMixingMessage()); } return expr; } isUnparenthesizedLogical(expr) { if (expr.type !== 'BinaryExpression' || this.parenthesized.has(expr)) return false; const operator = expr.operator; return operator === '||' || operator === '&&'; } nullishMixingMessage() { const token = this.peek(); return `Cannot mix '??' with '||' or '&&' without parentheses at line ${token.line}, column ${token.column}`; } or() { let expr = this.and(); while (this.match(types_1.TokenType.OR)) { const operator = this.previous(); const right = this.and(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } and() { let expr = this.bitwiseOr(); while (this.match(types_1.TokenType.AND)) { const operator = this.previous(); const right = this.bitwiseOr(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } bitwiseOr() { let expr = this.bitwiseXor(); while (this.match(types_1.TokenType.BITWISE_OR)) { const operator = this.previous(); const right = this.bitwiseXor(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } bitwiseXor() { let expr = this.bitwiseAnd(); while (this.match(types_1.TokenType.BITWISE_XOR)) { const operator = this.previous(); const right = this.bitwiseAnd(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } bitwiseAnd() { let expr = this.equality(); while (this.match(types_1.TokenType.BITWISE_AND)) { const operator = this.previous(); const right = this.equality(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } equality() { let expr = this.comparison(); while (this.match(types_1.TokenType.EQUAL, types_1.TokenType.NOT_EQUAL, types_1.TokenType.STRICT_EQUAL, types_1.TokenType.STRICT_NOT_EQUAL)) { const operator = this.previous(); const right = this.comparison(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } comparison() { let expr = this.privateNameInOperand() ?? this.shift(); // eslint-disable-next-line no-constant-condition while (true) { let operator; if (this.match(types_1.TokenType.GREATER_THAN, types_1.TokenType.GREATER_EQUAL, types_1.TokenType.LESS_THAN, types_1.TokenType.LESS_EQUAL)) { operator = this.previous().value; } else if (this.check(types_1.TokenType.ДАР) || this.checkIdentifierValue('in')) { this.advance(); operator = 'in'; } else if (this.checkIdentifierValue('instanceof')) { this.advance(); operator = 'instanceof'; } else if (this.typeOperator()) { expr = this.parseTypeOperator(expr); continue; } else { break; } const right = this.shift(); expr = { type: 'BinaryExpression', left: expr, operator, right, line: expr.line, column: expr.column, }; } return expr; } /** * The type operator at the current token, if any: `чун` / `as` (type * assertion) or `бармесоё` / `satisfies`. As in TypeScript they bind like * relational operators. `бармесоё`, `as` and `satisfies` are also ordinary * names, so they are operators only on the line of their operand. */ typeOperator() { if (this.check(types_1.TokenType.ЧУН)) return 'as'; if (this.hasLineBreakBefore()) return undefined; if (this.checkIdentifierValue('as')) return 'as'; if (this.check(types_1.TokenType.БАРМЕСОЁ) || this.checkIdentifierValue('satisfies')) { return 'satisfies'; } return undefined; } /** `х чун Т`, `х чун собит` (`as const`) or `х бармесоё Т`; types are erased. */ parseTypeOperator(expression) { const operator = this.typeOperator(); this.advance(); const position = { line: expression.line, column: expression.column }; if (operator === 'satisfies') { return { type: 'SatisfiesExpression', expression, typeAnnotation: this.parseType(), ...position, }; } if (this.matchConstKeyword()) { return { type: 'AsExpression', expression, isConst: true, ...position }; } return { type: 'AsExpression', expression, typeAnnotation: this.parseType(), ...position, }; } /** `собит` (or `const`) in `чун собит` / `<собит>`. */ matchConstKeyword() { if (this.check(types_1.TokenType.СОБИТ) || this.checkIdentifierValue('const')) { this.advance(); return true; } return false; } /** * `<Т>х` / `<собит>х`: TypeScript's prefix type assertion. A '<' starting * a generic arrow function never gets here (see `tryParseGenericArrowHead`). */ parseTypeAssertion() { const open = this.advance(); const isConst = this.peekNext()?.type === types_1.TokenType.GREATER_THAN && this.matchConstKeyword(); const typeAnnotation = isConst ? undefined : this.parseType(); this.consumeTypeArgumentsClose("Expected '>' after the type of a type assertion"); const expression = this.unary(); return { type: 'TypeAssertion', expression, ...(isConst ? { isConst } : { typeAnnotation }), line: open.line, column: open.column, }; } /** `#ном` directly before `in`/`дар` (the brand check `#ном in о`); anywhere else it is an error. */ privateNameInOperand() { const next = this.peekNext(); const beforeIn = next?.type === types_1.TokenType.ДАР || (next?.type === types_1.TokenType.IDENTIFIER && next.value === 'in'); if (!this.check(types_1.TokenType.PRIVATE_NAME) || !beforeIn) return undefined; return this.createMemberKey(this.advance()); } shift() { let expr = this.term(); while (this.match(types_1.TokenType.LEFT_SHIFT, types_1.TokenType.RIGHT_SHIFT, types_1.TokenType.UNSIGNED_RIGHT_SHIFT)) { const operator = this.previous(); const right = this.term(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } term() { let expr = this.factor(); while (this.match(types_1.TokenType.MINUS, types_1.TokenType.PLUS)) { const operator = this.previous(); const right = this.factor(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } factor() { let expr = this.exponent(); while (this.match(types_1.TokenType.DIVIDE, types_1.TokenType.MULTIPLY, types_1.TokenType.MODULO)) { const operator = this.previous(); const right = this.exponent(); expr = { type: 'BinaryExpression', left: expr, operator: operator.value, right, line: expr.line, column: expr.column, }; } return expr; } /** `а ** б`, right-associative. A unary operand on the left needs parentheses, as in JavaScript. */ exponent() { try { this.enterNesting(); const left = this.unary(); if (!this.check(types_1.TokenType.EXPONENT)) { return left; } if ((left.type === 'UnaryExpression' || left.type === 'AwaitExpression' || left.type === 'TypeAssertion') && !this.parenthesized.has(left)) { const token = this.peek(); const operand = left.type === 'TypeAssertion' ? 'Type assertion' : 'Unary operator'; throw new Error(`${operand} before '**' must be parenthesized at line ${token.line}, column ${token.column}`); } const operator = this.advance(); const right = this.exponent(); return { type: 'BinaryExpression', left, operator: operator.value, right, line: left.line, column: left.column, }; } finally { this.depth--; } } unary() { try { this.enterNesting(); if (this.match(types_1.TokenType.NOT, types_1.TokenType.MINUS, types_1.TokenType.PLUS, types_1.TokenType.BITWISE_NOT)) { const operator = this.previous(); const right = this.unary(); return { type: 'UnaryExpression', operator: operator.value, argument: right, line: operator.line, column: operator.column, }; } const keywordOperator = this.unaryKeywordOperator(); if (keywordOperator) { const operatorToken = this.advance(); const argument = this.unary(); return { type: 'UnaryExpression', operator: keywordOperator, argument, line: operatorToken.line, column: operatorToken.column, }; } if (this.match(types_1.TokenType.INCREMENT, types_1.TokenType.DECREMENT)) { const operator = this.previous(); const argument = this.unary(); this.checkUpdateOperand(argument, operator); return { type: 'UpdateExpression', operator: operator.value, argument, prefix: true, line: operator.line, column: operator.column, }; } if (this.match(types_1.TokenType.ИНТИЗОР)) { const awaitToken = this.previous(); const argument = this.unary(); return { type: 'AwaitExpression', argument, line: awaitToken.line, column: awaitToken.column, }; } // A '<' can only start an operand as the type assertion `<Т>х` if (this.check(types_1.TokenType.LESS_THAN)) { return this.parseTypeAssertion(); } return this.call(); } finally { this.depth--; } } /** * `навъи` / `typeof`, `void` and `delete` act as unary operators when an * operand follows; otherwise they are ordinary identifiers. `typeof`, * `void` and `delete` are reserved words, so `void -1` is `void (-1)`; * `навъи` is a name too, so `навъи - 1` stays a subtraction. */ unaryKeywordOperator() { const token = this.peek(); let operator = null; if (token.type === types_1.TokenType.НАВЪИ) { operator = 'typeof'; } else if (token.type === types_1.TokenType.IDENTIFIER && Parser.UNARY_KEYWORDS.has(token.value)) { operator = token.value; } if (!operator) return null; // The operator word is no EOF, so a token follows it const next = this.peekNext(); const startsOperand = this.isIdentifierNameToken(next) || [ types_1.TokenType.NUMBER, types_1.TokenType.STRING, types_1.TokenType.TEMPLATE_LITERAL, types_1.TokenType.REGEX, types_1.TokenType.LEFT_PAREN, types_1.TokenType.LEFT_BRACKET, types_1.TokenType.NOT, types_1.TokenType.BITWISE_NOT, ].includes(next.type) || // `навъи {}`: a name is never followed by `{` on its line (next.type === types_1.TokenType.LEFT_BRACE && next.line === token.line) || // `навъи --х`, but `навъи++` (a name, incremented) (Parser.isUpdateToken(next) && this.isOperandAfterUpdate(token)) || (token.type === types_1.TokenType.IDENTIFIER && [types_1.TokenType.MINUS, types_1.TokenType.PLUS].includes(next.type)); return startsOperand ? operator : null; } static isUpdateToken(token) { return token.type === types_1.TokenType.INCREMENT || token.type === types_1.TokenType.DECREMENT; } /** Whether `++`/`--` after a unary keyword updates the name after it, all on one line. */ isOperandAfterUpdate(keyword) { const update = this.tokens[this.current + 1]; const operand = this.tokens[this.current + 2]; return (operand !== undefined && this.isIdentifierNameToken(operand) && update.line === keyword.line && operand.line === keyword.line); } checkIdentifierValue(value) { return this.check(types_1.TokenType.IDENTIFIER) && this.peek().value === value; } call() { const expr = this.primary(); return this.applyCallChaining(expr); } applyCallChaining(expr) { // eslint-disable-next-line no-constant-condition while (true) { const typeArguments = this.parseTypeArgumentsInExpression(); if (typeArguments) { expr = this.applyTypeArguments(expr, typeArguments); } else if (this.match(types_1.TokenType.LEFT_PAREN)) { expr = this.finishCall(expr); } else if (this.match(types_1.TokenType.DOT)) { this.checkInstantiationAccess(expr); expr = this.createMemberExpression(expr, this.parsePropertyName("Expected property name after '.'"), false); } else if (this.match(types_1.TokenType.OPTIONAL_CHAINING)) { expr = this.optionalLink(expr); } else if (this.match(types_1.TokenType.LEFT_BRACKET)) { // Computed member expression: obj[expr] const property = this.expression(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property"); expr = this.createMemberExpression(expr, property, true); } else if (this.checkNonNullAssertion()) { expr = this.createNonNullExpression(expr); } else if (this.check(types_1.TokenType.TEMPLATE_LITERAL)) { expr = this.parseTaggedTemplate(expr); } else if (this.match(types_1.TokenType.INCREMENT, types_1.TokenType.DECREMENT)) { // Postfix increment/decrement const operator = this.previous(); this.checkUpdateOperand(expr, operator); expr = { type: 'UpdateExpression', operator: operator.value, argument: expr, prefix: false, line: expr.line, column: expr.column, }; } else { break; } } return expr; } /** * After `?.`: an optional call `ф?.(…)` (also with type arguments, * `ф?.<Т>(…)`), element `о?.[к]` or property `о?.ном`. */ optionalLink(expr) { const typeArguments = this.parseTypeArgumentsInExpression(); if (this.match(types_1.TokenType.LEFT_PAREN)) { const call = this.finishCall(expr, typeArguments); call.optional = true; return call; } if (typeArguments) { throw new Error(this.unexpectedTokenMessage("Expected '(' after type arguments")); } let member; if (this.match(types_1.TokenType.LEFT_BRACKET)) { const property = this.expression(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property"); member = this.createMemberExpression(expr, property, true); } else { this.checkInstantiationAccess(expr); member = this.createMemberExpression(expr, this.parsePropertyName("Expected property name after '?.'"), false); } member.optional = true; return member; } /** * Type arguments after an operand: a call `ф<Т>(…)`, a tagged template * `т<Т>\`…\`` or, followed by anything else, an instantiation expression `ф<Т>`. */ applyTypeArguments(expr, typeArguments) { if (this.match(types_1.TokenType.LEFT_PAREN)) return this.finishCall(expr, typeArguments); if (this.check(types_1.TokenType.TEMPLATE_LITERAL)) { return this.parseTaggedTemplate(expr, typeArguments); } return this.createInstantiation(expr, typeArguments); } createInstantiation(expression, typeArguments) { return { type: 'InstantiationExpression', expression, typeArguments, line: expression.line, column: expression.column, }; } /** TypeScript's TS1477: `ф<Т>.ном` is an error (`(ф<Т>).ном` is not). */ checkInstantiationAccess(expr) { if (expr.type !== 'InstantiationExpression' || this.parenthesized.has(expr)) return; const token = this.previous(); this.errors.push(`An instantiation expression cannot be followed by a property access at line ${token.line}, column ${token.column}`); } /** * A '!' right after an operand, on its line, is the non-null assertion * `х!` (as in TypeScript); `!=` and `!==` are separate tokens. */ checkNonNullAssertion() { return this.check(types_1.TokenType.NOT) && !this.hasLineBreakBefore(); } createNonNullExpression(expression) { this.advance(); // '!' return { type: 'NonNullExpression', expression, line: expression.line, column: expression.column, }; } createMemberExpression(object, property, computed) { return { type: 'MemberExpression', object, property, computed, line: object.line, column: object.column, }; } /** * A template literal right after a member/call expression tags it, as in * JavaScript (also across a line break): `тег\`…\``, `о.метод\`…\``. */ parseTaggedTemplate(tag, typeArguments) { const template = this.peek(); if (this.containsOptionalLink(tag)) { throw new Error(`Invalid tagged template on optional chain at line ${template.line}, column ${template.column}`); } this.advance(); return { type: 'TaggedTemplateExpression', tag, quasi: this.parseTemplateLiteral(true), ...(typeArguments && { typeArguments }), line: tag.line, column: tag.column, }; } /** Property name after '.' or '?.': any identifier or keyword, or a private name (`ин.#х`). */ parsePropertyName(message) { if (this.check(types_1.TokenType.PRIVATE_NAME)) { return this.createMemberKey(this.advance()); } if (!this.isIdentifierNameToken(this.peek())) { throw new Error(this.unexpectedTokenMessage(message)); } return this.createIdentifier(this.advance()); } /** Name of a class member: an identifier, or a `PrivateIdentifier` for `#ном`. */ createMemberKey(token) { if (token.type !== types_1.TokenType.PRIVATE_NAME) return this.createIdentifier(token); return { type: 'PrivateIdentifier', name: token.value.slice(1), line: token.line, column: token.column, }; } /** Identifiers and keywords: every token whose text is a word. */ isIdentifierNameToken(token) { if (token.type === types_1.TokenType.IDENTIFIER) return true; if (token.type === types_1.TokenType.STRING || token.type === types_1.TokenType.NUMBER || token.type === types_1.TokenType.TEMPLATE_LITERAL || token.type === types_1.TokenType.EOF) { return false; } return /^[\p{L}_$][\p{L}\p{N}\p{M}_$]*$/u.test(token.value); } /** * Type arguments in an expression, read as TypeScript reads them * (`parseTypeArgumentsInExpression`): a `<…>` whose content parses as types * and that is followed by `(`, a template, a line break, a binary operator * or a token that cannot start an expression — `ф<рақам>(1)`, `ф<ҳар>`, * `нав К<Т>()`. Otherwise nothing is consumed and the `<` compares: * `а < б > в`, `а < б > +1`. */ parseTypeArgumentsInExpression() { if (!this.check(types_1.TokenType.LESS_THAN)) return undefined; const typeArguments = this.speculateCleanly(() => { // As in TypeScript, the closing `>` is no part of `>>` or `>=`: `а < А<б >> в` compares const list = this.parseTypeArgumentList(false); return this.canFollowTypeArguments() ? list : undefined; }); return typeArguments ?? undefined; } /** * `<Т, У>`, at the `<`. A `>>` closing nested lists is split; `splitClose`: * the list's own `>` may be split from a `>>` or `>>>` too. */ parseTypeArgumentList(splitClose = true) { this.advance(); // '<' const typeArguments = []; do { typeArguments.push(this.parseType()); } while (this.match(types_1.TokenType.COMMA)); if (splitClose) this.consumeTypeArgumentsClose(); else this.consume(types_1.TokenType.GREATER_THAN, "Expected '>' after type arguments"); return typeArguments; } /** TypeScript's `canFollowTypeArgumentsInExpression`. */ canFollowTypeArguments() { const token = this.peek(); switch (token.type) { case types_1.TokenType.LEFT_PAREN: case types_1.TokenType.TEMPLATE_LITERAL: return true; // `ф<Т><У>` makes no sense, `ф<Т> > х` is ambiguous with `>>`, and `+`/`-` are unary here case types_1.TokenType.LESS_THAN: case types_1.TokenType.GREATER_THAN: case types_1.TokenType.PLUS: case types_1.TokenType.MINUS: return false; default: return (this.hasLineBreakBefore() || this.isBinaryOperatorToken(token) || !this.startsOperand(token)); } } isBinaryOperatorToken(token) { return (Parser.BINARY_OPERATOR_TOKENS.has(token.type) || (token.type === types_1.TokenType.IDENTIFIER && Parser.BINARY_OPERATOR_WORDS.has(token.value))); } /** Whether `token` can start an operand: a literal, a word or an opening punctuator. */ startsOperand(token) { return Parser.OPERAND_START_TOKENS.has(token.type) || this.isIdentifierNameToken(token); } /** The call of `callee`, after its consumed '('. */ finishCall(callee, typeArguments) { const args = this.parseArguments(); return { type: 'CallExpression', callee, arguments: args, ...(typeArguments && { typeArguments }), line: callee.line, column: callee.column, }; } /** Arguments after a consumed '(' up to and including ')'; spread allowed. */ parseArguments() { const args = []; while (!this.check(types_1.TokenType.RIGHT_PAREN)) { args.push(this.spreadOrAssignment()); if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after arguments"); return args; } /** An element of an array literal, object literal or argument list. */ spreadOrAssignment() { if (this.match(types_1.TokenType.SPREAD)) { const spreadToken = this.previous(); return { type: 'SpreadElement', argument: this.assignment(), line: spreadToken.line, column: spreadToken.column, }; } return this.assignment(); } createLiteral(value, token) { const raw = typeof value === 'string' ? `"${value}"` : token.value; return { type: 'Literal', value, raw, line: token.line, column: token.column, }; } /** The NUMBER token holds the literal as written (`0xFF`, `1e3`, `10n`); codegen emits `raw`. */ createNumericLiteral(token) { const text = token.value.endsWith('n') ? token.value.slice(0, -1) : token.value; return { type: 'Literal', value: Number(text), raw: token.value, line: token.line, column: token.column, }; } parseNewExpression(token) { // The callee is a member chain without calls: `нав а.Б()` constructs `а.Б` let callee = this.primary(); // eslint-disable-next-line no-constant-condition while (true) { if (this.match(types_1.TokenType.DOT)) { callee = this.createMemberExpression(callee, this.parsePropertyName("Expected property name after '.'"), false); } else if (this.match(types_1.TokenType.LEFT_BRACKET)) { const property = this.expression(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property"); callee = this.createMemberExpression(callee, property, true); } else if (this.checkNonNullAssertion()) { // `нав а!.Б()` constructs `а!.Б` callee = this.createNonNullExpression(callee); } else if (this.check(types_1.TokenType.TEMPLATE_LITERAL)) { // `нав К\`…\`()` constructs the result of the tagged template, as in JavaScript callee = this.parseTaggedTemplate(callee); } else { break; } } const typeArguments = this.parseTypeArgumentsInExpression(); // `нав а?.Б()` is a SyntaxError in JavaScript (TypeScript's TS1209); `нав а()?.б` is not const chain = this.check(types_1.TokenType.OPTIONAL_CHAINING) ? this.peek() : undefined; if (chain) { this.errors.push(`Invalid optional chain from new expression at line ${chain.line}, column ${chain.column}`); } // Arguments are optional: `нав Сана` const args = this.match(types_1.TokenType.LEFT_PAREN) ? this.parseArguments() : []; return { type: 'NewExpression', callee, arguments: args, ...(typeArguments && { typeArguments }), line: token.line, column: token.column, }; } /** Type arguments of a heritage clause: `мерос Асос<рақам>`. */ parseNewTypeArguments() { return this.check(types_1.TokenType.LESS_THAN) ? this.parseTypeArgumentList() : undefined; } parseDynamicImport(importToken, keyword = 'ворид') { this.consume(types_1.TokenType.LEFT_PAREN, `Expected '(' after '${keyword}'`); const source = this.assignment(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after import specifier"); return { type: 'ImportExpression', source, line: importToken.line, column: importToken.column, }; } parseFunctionExpression(funcToken) { const generator = this.match(types_1.TokenType.MULTIPLY); // `функсия ном(…) { … }`: a name bound in the function's body only const name = this.match(types_1.TokenType.IDENTIFIER) || this.matchBuiltinIdentifier() ? this.createIdentifier(this.previous()) : undefined; const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'функсия'"); const { params, thisType } = this.withGenerator(false, () => this.parseParametersWithThis("Expected ')' after parameters")); let returnType; if (this.match(types_1.TokenType.COLON)) { returnType = this.returnTypeAnnotation(); } this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' before function body"); const body = this.withGenerator(generator, () => this.blockStatement()); return { type: 'FunctionExpression', ...(name && { name }), ...(typeParameters && { typeParameters }), params, body, returnType, ...(generator && { generator }), ...(thisType && { thisType }), line: funcToken.line, column: funcToken.column, }; } createIdentifier(token) { return { type: 'Identifier', name: token.value, line: token.line, column: token.column, }; } parseLiteralExpression() { if (this.match(types_1.TokenType.ДУРУСТ)) { return this.createLiteral(true, this.previous()); } if (this.match(types_1.TokenType.НОДУРУСТ)) { return this.createLiteral(false, this.previous()); } if (this.match(types_1.TokenType.ХОЛӢ)) { return this.createLiteral(null, this.previous()); } if (this.match(types_1.TokenType.NUMBER)) { return this.createNumericLiteral(this.previous()); } if (this.match(types_1.TokenType.STRING)) { return this.createLiteral(this.previous().value, this.previous()); } if (this.match(types_1.TokenType.TEMPLATE_LITERAL)) { return this.parseTemplateLiteral(); } if (this.match(types_1.TokenType.REGEX)) { return this.createRegExpLiteral(this.previous()); } return null; } /** The REGEX token holds the literal as written: `/а+/g`. */ createRegExpLiteral(token) { const closing = token.value.lastIndexOf('/'); return { type: 'RegExpLiteral', pattern: token.value.slice(1, closing), flags: token.value.slice(closing + 1), line: token.line, column: token.column, }; } parseThisOrSuperExpression() { if (this.match(types_1.TokenType.ИН)) { const token = this.previous(); return { type: 'ThisExpression', line: token.line, column: token.column }; } if (this.match(types_1.TokenType.СУПЕР)) { const token = this.previous(); return { type: 'Super', line: token.line, column: token.column }; } return null; } parseIdentifierExpression() { if (this.match(types_1.TokenType.IDENTIFIER) || this.matchBuiltinIdentifier()) { return this.createIdentifier(this.previous()); } if (this.match(types_1.TokenType.НАВЪ, types_1.TokenType.МАЪЛУМОТ, types_1.TokenType.РӮЙХАТ, types_1.TokenType.БЕҚИМАТ)) { return this.createIdentifier(this.previous()); } return null; } parseGroupingOrCollection() { if (this.match(types_1.TokenType.LEFT_PAREN)) { let expr = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after expression"); if (this.containsOptionalLink(expr)) { expr = { type: 'ChainExpression', expression: expr, line: expr.line, column: expr.column, }; } this.parenthesized.add(expr); return expr; } if (this.match(types_1.TokenType.LEFT_BRACKET)) { return this.arrayExpression(); } if (this.match(types_1.TokenType.LEFT_BRACE)) { return this.objectExpression(); } return null; } /** Whether the member/call chain of `expr` (assertions included) has a `?.` link. */ containsOptionalLink(expr) { let current = expr; // eslint-disable-next-line no-constant-condition while (true) { if (current.type === 'MemberExpression' || current.type === 'CallExpression') { if (current.optional) return true; current = current.type === 'MemberExpression' ? current.object : current.callee; } else if (Parser.ASSERTION_TYPES.has(current.type)) { // `(о?.а чун Т).б` and `(о?.а!).б` end the chain like `(о?.а).б` current = current.expression; } else { return false; } } } primary() { const literal = this.parseLiteralExpression(); if (literal) return literal; const thisOrSuper = this.parseThisOrSuperExpression(); if (thisOrSuper) return thisOrSuper; if (this.check(types_1.TokenType.НАВ) && this.peekNext()?.type === types_1.TokenType.DOT) { return this.parseNewTarget(); } if (this.match(types_1.TokenType.НАВ)) { return this.parseNewExpression(this.previous()); } const importExpression = this.parseImportExpressionOrMeta(); if (importExpression) return importExpression; if (this.match(types_1.TokenType.ФУНКСИЯ)) { return this.parseFunctionExpression(this.previous()); } if (this.startsClassExpression()) { return this.classExpression(); } if (this.isAsyncFunctionStart()) { const asyncToken = this.advance(); this.advance(); // consume 'функсия' const func = this.parseFunctionExpression(asyncToken); func.async = true; return func; } if (this.isYieldKeyword(this.peek())) { // `а + ҳосил б`: as in JavaScript, a yield operand needs parentheses throw new Error(this.unexpectedTokenMessage(`'${this.peek().value}' used as an operand must be parenthesized`)); } const identifier = this.parseIdentifierExpression(); if (identifier) return identifier; const grouping = this.parseGroupingOrCollection(); if (grouping) return grouping; throw this.unexpectedOperandError(); } /** The error for a token that starts no operand. */ unexpectedOperandError() { const token = this.peek(); const at = `at line ${token.line}, column ${token.column}`; // The lexer reads '/' as a regular expression only when it is closed on its line if (token.type === types_1.TokenType.DIVIDE || token.type === types_1.TokenType.DIVIDE_ASSIGN) { return new Error(`Unterminated regular expression ${at}`); } const shown = token.type === types_1.TokenType.EOF ? 'end of input' : `'${token.value}'`; return new Error(`Unexpected token ${shown} ${at}`); } /** `нав.target` (`new.target`); the only meta property of `нав`. */ parseNewTarget() { const newToken = this.advance(); this.advance(); // '.' const property = this.peek(); if (property.type !== types_1.TokenType.IDENTIFIER || property.value !== 'target') { throw new Error(`The only valid meta property for 'нав' is 'нав.target' at line ${property.line}, column ${property.column}`); } this.advance(); return { type: 'MetaProperty', meta: { type: 'Identifier', name: 'new', line: newToken.line, column: newToken.column }, property: this.createIdentifier(property), line: newToken.line, column: newToken.column, }; } /** * `ворид(…)` (dynamic import), `ворид.мавқуф(…)` (`import.defer`) or * `ворид.meta`; null when `ворид` starts no expression. */ parseImportExpressionOrMeta() { if (!this.check(types_1.TokenType.ВОРИД)) return null; const next = this.peekNext()?.type; if (next === types_1.TokenType.LEFT_PAREN) return this.parseDynamicImport(this.advance()); return next === types_1.TokenType.DOT ? this.parseImportMeta() : null; } /** * `ворид.meta` (`import.meta`), or `ворид.мавқуф(…)` (`import.defer(…)`, * TypeScript 5.9): a promise of the module's deferred namespace. */ parseImportMeta() { const importToken = this.advance(); this.advance(); // '.' const property = this.peek(); if (property.type === types_1.TokenType.IDENTIFIER && Parser.DEFER_KEYWORDS.has(property.value)) { this.advance(); const call = this.parseDynamicImport(importToken, `ворид.${property.value}`); return { ...call, phase: 'defer' }; } if (property.type !== types_1.TokenType.IDENTIFIER || property.value !== 'meta') { throw new Error(`The only valid meta properties for 'ворид' are 'ворид.meta' and 'ворид.мавқуф(…)' at line ${property.line}, column ${property.column}`); } this.advance(); return { type: 'MetaProperty', meta: { type: 'Identifier', name: 'import', line: importToken.line, column: importToken.column, }, property: this.createIdentifier(property), line: importToken.line, column: importToken.column, }; } /** * The template literal just consumed. In a tagged template (`tagged`) an * invalid escape is allowed and leaves the text's `cooked` value null. */ parseTemplateLiteral(tagged = false) { const token = this.previous(); const quasis = []; const expressions = []; for (const part of this.splitTemplate(token.value)) { if (part.type === 'text') { quasis.push({ type: 'TemplateElement', value: { raw: part.value, cooked: this.cookTemplatePart(part.value, token, tagged) }, tail: false, line: token.line, column: token.column, }); } else { const { line, column } = this.templateOffsetPosition(token, part.offset); expressions.push(this.parseInterpolation(part.value, line, column)); } } quasis[quasis.length - 1].tail = true; return { type: 'TemplateLiteral', quasis, expressions, line: token.line, column: token.column, }; } /** * Splits raw template text into alternating text / `${…}` parts, always * starting and ending with text. `\${` is text; braces inside strings and * nested templates do not end an interpolation. */ splitTemplate(raw) { const parts = []; let textStart = 0; let i = 0; while (i < raw.length) { if (raw[i] === '\\') { i += 2; } else if (raw[i] === '$' && raw[i + 1] === '{') { parts.push({ type: 'text', value: raw.slice(textStart, i), offset: textStart }); const end = this.findInterpolationEnd(raw, i + 2); parts.push({ type: 'expression', value: raw.slice(i + 2, end), offset: i + 2 }); i = end + 1; textStart = i; } else { i++; } } parts.push({ type: 'text', value: raw.slice(textStart), offset: textStart }); return parts; } /** * Index of the '}' that closes an interpolation whose body starts at `start`; * braces in strings, nested templates, regular expressions and comments do not count. */ findInterpolationEnd(raw, start) { let depth = 1; let i = start; while (i < raw.length) { const char = raw[i]; const skipped = char === '/' ? this.skipCommentOrRegex(raw, i, start) : -1; if (skipped !== -1) { i = skipped; } else if (char === '"' || char === "'") { i = this.skipQuoted(raw, i + 1, char); } else if (char === '`') { i = this.skipNestedTemplate(raw, i + 1); } else if (char === '{') { depth++; i++; } else if (char === '}') { if (--depth === 0) return i; i++; } else { i++; } } return raw.length; } /** * At the '/' at `i` of an interpolation starting at `start`: the index just * past a comment or regular expression literal there, or -1 for a division. */ skipCommentOrRegex(raw, i, start) { if (raw[i + 1] === '/') { const newline = raw.indexOf('\n', i); return newline === -1 ? raw.length : newline; } if (raw[i + 1] === '*') { const close = raw.indexOf('*/', i + 2); return close === -1 ? raw.length : close + 2; } return (0, lexer_1.isRegexStartInText)(raw, i, start) ? (0, lexer_1.regexLiteralEnd)(raw, i) : -1; } /** Index just past the closing `quote` of a string starting at `i`. */ skipQuoted(raw, i, quote) { while (i < raw.length && raw[i] !== quote) { i += raw[i] === '\\' ? 2 : 1; } return i + 1; } /** Index just past the closing backtick of a nested template starting at `i`. */ skipNestedTemplate(raw, i) { while (i < raw.length && raw[i] !== '`') { if (raw[i] === '\\') { i += 2; } else if (raw[i] === '$' && raw[i + 1] === '{') { i = this.findInterpolationEnd(raw, i + 2) + 1; } else { i++; } } return i + 1; } /** Source position of `offset` within the raw text of a template token. */ templateOffsetPosition(token, offset) { const before = token.value.slice(0, offset); const lastBreak = before.lastIndexOf('\n'); const breaks = before.split('\n').length - 1; return breaks === 0 ? { line: token.line, column: token.column + 1 + offset } : { line: token.line + breaks, column: offset - lastBreak }; } cookTemplatePart(raw, token, tagged) { if (!tagged) return this.cookTemplateText(raw, token); try { return this.cookTemplateText(raw, token); } catch { return null; } } /** Decodes the escape sequences of raw template text. */ cookTemplateText(raw, token) { const simple = { n: '\n', t: '\t', r: '\r', b: '\b', f: '\f', v: '\v', '0': '\0', '\n': '', }; // Line terminators are normalized to '\n', as in JavaScript return raw .replace(/\r\n?/g, '\n') .replace(/\\(u\{([0-9a-fA-F]+)\}|u([0-9a-fA-F]{4})|x([0-9a-fA-F]{2})|[\s\S])/g, (whole, escape, braced, unicode, hex) => { const code = braced ?? unicode ?? hex; if (code !== undefined) { const point = Number.parseInt(code, 16); if (point > 0x10ffff) { throw new Error(`Invalid Unicode escape '${whole}' in template literal at line ${token.line}, column ${token.column}`); } return String.fromCodePoint(point); } if (escape === 'u' || escape === 'x') { throw new Error(`Invalid escape sequence '${whole}' in template literal at line ${token.line}, column ${token.column}`); } return simple[escape] ?? escape; }); } /** * Parses the source of one `${…}` with a sub-parser. Tokens are shifted to * their real position, the expression must consume all of them, and every * error is reported through this parser. */ parseInterpolation(source, line, column) { if (!source.trim()) { // `${}` is treated as `undefined` return { type: 'Identifier', name: 'undefined', line, column }; } return this.parseSubSource(source, line, column, sub => sub.expression(), "Expected '}' after template expression"); } /** * Parses `source`, text of this input starting at `line`/`column`, with a * sub-parser: `parse` must consume all of its tokens. */ parseSubSource(source, line, column, parse, endMessage) { let tokens; try { tokens = new lexer_1.Lexer(source, { expression: true }).tokenize(); } catch (error) { // The lexer reports problems with Errors throw new Error(this.shiftPositions(error.message, line, column)); } for (const token of tokens) { if (token.line === 1) token.column += column - 1; token.line += line - 1; } const subParser = new Parser(tokens); subParser.depth = this.depth; subParser.inGenerator = this.inGenerator; let result; try { result = parse(subParser); if (!subParser.isAtEnd()) { throw new Error(subParser.unexpectedTokenMessage(endMessage)); } // A whole sub-source is no destructuring target: `${ ({ а = 1 }) }` subParser.reportCoverInitializers([]); } finally { this.errors.push(...subParser.errors); } return result; } /** Rewrites `line L, column C` of a message produced for a sub-source starting at line/column. */ shiftPositions(message, line, column) { return message.replace(/line (\d+), column (\d+)/g, (_match, l, c) => { const subLine = Number(l); const realColumn = subLine === 1 ? Number(c) + column - 1 : Number(c); return `line ${subLine + line - 1}, column ${realColumn}`; }); } /** True when the upcoming tokens have exactly these types. */ checkSequence(...types) { return types.every((type, offset) => this.tokens[this.current + offset]?.type === type); } match(...types) { for (const type of types) { if (this.check(type)) { this.advance(); return true; } } return false; } check(type) { if (this.isAtEnd()) return false; return this.peek().type === type; } advance() { if (!this.isAtEnd()) this.current++; return this.previous(); } isAtEnd() { return this.peek().type === types_1.TokenType.EOF; } /** The tokens end with EOF, past which `advance` never moves. */ peek() { return this.tokens[this.current]; } peekNext() { if (this.current + 1 >= this.tokens.length) return undefined; return this.tokens[this.current + 1]; } /** The last consumed token: there is one wherever this is asked. */ previous() { return this.tokens[this.current - 1]; } consume(type, message) { if (this.check(type)) return this.advance(); throw new Error(this.unexpectedTokenMessage(message)); } /** * Statement terminator. As in JavaScript, ';' may be omitted before '}', at * the end of input, or when the next token starts on a new line. */ consumeSemicolon(message, member = false) { if (this.match(types_1.TokenType.SEMICOLON)) return; if (this.check(types_1.TokenType.RIGHT_BRACE) || this.isAtEnd() || this.hasLineBreakBefore()) { this.noteOmittedSemicolon(member); return; } throw new Error(this.unexpectedTokenMessage(message)); } /** Records that the `;` before the current token was left out. */ noteOmittedSemicolon(member = false) { this.omittedSemicolons.push({ before: this.peek(), member }); } /** Separator after an interface or object-type member: ';' or ','. */ consumeMemberSeparator(message) { if (this.match(types_1.TokenType.COMMA)) return; this.consumeSemicolon(message, true); } /** True when the current token starts on a later line than the previous one ended. */ hasLineBreakBefore() { const previous = this.previous(); // Template literals are the only tokens whose value keeps their line breaks const lastLine = previous.type === types_1.TokenType.TEMPLATE_LITERAL ? previous.line + (previous.value.match(/\n/g)?.length ?? 0) : previous.line; return this.peek().line > lastLine; } unexpectedTokenMessage(message) { const token = this.peek(); const shown = token.type === types_1.TokenType.EOF ? 'end of input' : `'${token.value}'`; return `Unexpected token ${shown} at line ${token.line}, column ${token.column} (${message})`; } /** `навъ` / `type` before import or export specifiers: `ворид навъ { Т } аз "./м";`. */ isTypeOnlyModifier() { const token = this.peek(); const next = this.peekNext(); const isWord = token.type === types_1.TokenType.НАВЪ || (token.type === types_1.TokenType.IDENTIFIER && token.value === 'type'); if (!isWord || !next) return false; if (next.type === types_1.TokenType.LEFT_BRACE || next.type === types_1.TokenType.MULTIPLY) return true; // `ворид навъ Т аз …`, `ворид навъ Т = require(…)`; `ворид type аз …` imports `type` const after = this.tokens[this.current + 2]?.type; return (this.isPlainIdentifierToken(next) && (after === types_1.TokenType.АЗ || after === types_1.TokenType.COMMA || after === types_1.TokenType.ASSIGN)); } /** `навъ` / `type` before one specifier: `{ навъ Т, х }`. */ matchSpecifierTypeModifier() { const token = this.peek(); const next = this.peekNext(); const isWord = token.type === types_1.TokenType.НАВЪ || (token.type === types_1.TokenType.IDENTIFIER && token.value === 'type'); if (!isWord || !next) return false; if (next.type !== types_1.TokenType.IDENTIFIER && !this.isBuiltinIdentifierType(next.type)) { return false; } this.advance(); return true; } /** * `ворид х = require("./м");` / `ворид х = Н.а;` (TypeScript `import x = …`), * at the name. */ importEqualsDeclaration(importToken, typeOnly) { const id = this.createIdentifier(this.advance()); this.consume(types_1.TokenType.ASSIGN, "Expected '=' after import name"); const declaration = { type: 'ImportEqualsDeclaration', id, ...(typeOnly && { importKind: 'type' }), line: importToken.line, column: importToken.column, }; if (this.checkIdentifierValue('require') && this.peekNext()?.type === types_1.TokenType.LEFT_PAREN) { this.advance(); // 'require' this.advance(); // '(' const source = this.consume(types_1.TokenType.STRING, "Expected module path in 'require'"); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after module path"); declaration.source = { type: 'Literal', value: source.value, raw: `"${source.value}"`, line: source.line, column: source.column, }; } else { let reference = this.createIdentifier(this.parseImportOrExportName('Expected a name or require("…") after \'=\'')); while (this.match(types_1.TokenType.DOT)) { reference = this.createMemberExpression(reference, this.parsePropertyName("Expected property name after '.'"), false); } declaration.reference = reference; } this.consumeSemicolon("Expected ';' after import"); return declaration; } importDeclaration(importToken = this.previous()) { const specifiers = []; // `ворид навъ { Т } аз "./м";`: types only const typeOnly = this.isTypeOnlyModifier(); if (typeOnly) this.advance(); if (this.isPlainIdentifierToken(this.peek()) && this.peekNext()?.type === types_1.TokenType.ASSIGN) { return this.importEqualsDeclaration(importToken, typeOnly); } // Side-effect import: `ворид "./м";` runs the module and binds nothing if (!typeOnly && this.check(types_1.TokenType.STRING)) { const source = this.advance(); this.consumeSemicolon("Expected ';' after import"); return { type: 'ImportDeclaration', specifiers, source: { type: 'Literal', value: source.value, raw: `"${source.value}"`, line: source.line, column: source.column, }, line: importToken.line, column: importToken.column, }; } // `ворид мавқуф * чун Н аз "./м";`: the module runs when a member of `Н` is first read const deferred = !typeOnly && this.isDeferredImport(); if (deferred) this.advance(); this.parseImportClause(specifiers); this.consume(types_1.TokenType.АЗ, "Expected 'аз' after import specifiers"); const source = this.consume(types_1.TokenType.STRING, 'Expected module path'); this.consumeSemicolon("Expected ';' after import"); if (typeOnly) this.checkTypeOnlyImport(specifiers, importToken); if (deferred) this.checkDeferredImport(specifiers); return { type: 'ImportDeclaration', specifiers, source: { type: 'Literal', value: source.value, raw: `"${source.value}"`, line: source.line, column: source.column, }, ...(typeOnly && { importKind: 'type' }), ...(deferred && { phase: 'defer' }), line: importToken.line, column: importToken.column, }; } /** The bindings of an import: `а`, `* чун Н`, `{ б, в чун г }`, `а, { б }`, `а, * чун Н`. */ parseImportClause(specifiers) { // A default import binds any name a variable may have (`маълумот`, `рӯйхат`, …) if (this.isPlainIdentifierToken(this.peek())) { const local = this.advance(); specifiers.push({ type: 'ImportDefaultSpecifier', local: { type: 'Identifier', name: local.value, line: local.line, column: local.column, }, line: local.line, column: local.column, }); if (this.match(types_1.TokenType.COMMA)) { if (this.match(types_1.TokenType.MULTIPLY)) { // `ворид а, * чун Н аз "./м";` specifiers.push(this.parseNamespaceImportSpecifier()); } else { // Handle named imports after default this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after default import"); this.parseNamedImports(specifiers); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after named imports"); } } } else if (this.match(types_1.TokenType.MULTIPLY)) { specifiers.push(this.parseNamespaceImportSpecifier()); } else if (this.match(types_1.TokenType.LEFT_BRACE)) { // Handle only named imports this.parseNamedImports(specifiers); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after named imports"); } } /** * `ворид мавқуф * чун Н …`: the word defers the import when an import * clause follows it. `ворид мавқуф аз "./м";` imports a default named * `мавқуф`, as `import defer from "./m"` does in TypeScript. */ isDeferredImport() { const token = this.peek(); const next = this.peekNext(); if (!next || token.type !== types_1.TokenType.IDENTIFIER || !Parser.DEFER_KEYWORDS.has(token.value)) { return false; } if (next.type === types_1.TokenType.MULTIPLY || next.type === types_1.TokenType.LEFT_BRACE) return true; // `ворид мавқуф х аз "./м";`: a deferred default import, which is an error return (this.isPlainIdentifierToken(next) && this.tokens[this.current + 2]?.type === types_1.TokenType.АЗ); } /** * TypeScript's rule for `ворид мавқуф`: only the namespace is imported * (TS18058, TS18059), since no other binding can wait for the module to run. */ checkDeferredImport(specifiers) { const reported = new Set(); for (const spec of specifiers) { if (spec.type === 'ImportNamespaceSpecifier') continue; const kind = spec.type === 'ImportDefaultSpecifier' ? 'Default' : 'Named'; if (reported.has(kind)) continue; reported.add(kind); this.errors.push(`${kind} imports are not allowed in a deferred import; import the namespace: 'ворид мавқуф * чун Н аз …' at line ${spec.line}, column ${spec.column}`); } } /** TypeScript's rules for `ворид навъ`: a default import or named imports, not both. */ checkTypeOnlyImport(specifiers, importToken) { const at = `at line ${importToken.line}, column ${importToken.column}`; const hasDefault = specifiers.some(spec => spec.type === 'ImportDefaultSpecifier'); if (hasDefault && specifiers.length > 1) { this.errors.push(`A type-only import can specify a default import or named bindings, but not both ${at}`); } if (specifiers.some(spec => spec.type === 'ImportSpecifier' && spec.importKind)) { this.errors.push(`The 'навъ' modifier cannot be used on a named import when 'ворид навъ' is used on its import statement ${at}`); } } /** `* чун Н` of a namespace import, after the consumed '*'. */ parseNamespaceImportSpecifier() { this.consume(types_1.TokenType.ЧУН, "Expected 'чун' after '*' in namespace import"); let local; if (this.check(types_1.TokenType.IDENTIFIER)) { local = this.advance(); } else if (this.matchBuiltinIdentifier()) { local = this.previous(); } else { const token = this.peek(); throw new Error(`Expected namespace alias after 'чун' at line ${token.line}, column ${token.column}`); } return { type: 'ImportNamespaceSpecifier', local: { type: 'Identifier', name: local.value, line: local.line, column: local.column, }, line: local.line, column: local.column, }; } parseImportOrExportName(errorMessage) { if (this.check(types_1.TokenType.IDENTIFIER)) { return this.advance(); } if (this.matchBuiltinIdentifier()) { return this.previous(); } throw new Error(`${errorMessage} at line ${this.peek().line}, column ${this.peek().column}`); } /** * The name a module exports, in `ворид { ном чун х }` and * `содир { х чун ном }`: any word, as in JavaScript (`пешфарз` is * `default`), or any string (`"а-б"`, TypeScript 5.6). */ parseModuleExportName(errorMessage) { const token = this.peek(); if (token.type === types_1.TokenType.STRING) return this.advance(); if (!this.isIdentifierNameToken(token)) { throw new Error(`${errorMessage} at line ${token.line}, column ${token.column}`); } this.advance(); return token.type === types_1.TokenType.ПЕШФАРЗ ? { ...token, value: 'default' } : token; } /** * A keyword or string imported or exported by name needs `чун`: * `{ пешфарз чун х }`, `{ "а-б" чун х }`; only a name names a local binding. */ checkBindingName(name) { if (this.isPlainIdentifierToken(name)) return; const at = `at line ${name.line}, column ${name.column}`; if (name.type === types_1.TokenType.STRING) { this.errors.push(`The string "${name.value}" cannot be a local name: import it as '"${name.value}" чун ном', export a name as 'ном чун "${name.value}"' ${at}`); return; } this.errors.push(`'${name.value}' is a keyword and cannot be a local name; write '${name.value} чун ном' ${at}`); } /** The identifier of a module export name; a string is marked `isString`. */ moduleExportName(token) { const identifier = this.createIdentifier(token); if (token.type === types_1.TokenType.STRING) identifier.isString = true; return identifier; } createImportSpecifier(imported, local) { return { type: 'ImportSpecifier', imported: this.moduleExportName(imported), local: { type: 'Identifier', name: local.value, line: local.line, column: local.column, }, line: imported.line, column: imported.column, }; } parseNamedImports(specifiers) { if (this.check(types_1.TokenType.RIGHT_BRACE)) { return; } do { // A trailing comma is allowed: `{ а, б, }` if (specifiers.length > 0 && this.check(types_1.TokenType.RIGHT_BRACE)) break; const typeOnly = this.matchSpecifierTypeModifier(); // `{ пешфарз чун х }`: any exported name, but the local one must be a name const imported = this.parseModuleExportName('Expected import name'); let local = imported; if (this.match(types_1.TokenType.ЧУН)) { local = this.parseImportOrExportName("Expected local name after 'чун'"); } else { this.checkBindingName(imported); // `{ "а-б" }` binds no name: an error, and nothing is imported if (imported.type === types_1.TokenType.STRING) continue; } const specifier = this.createImportSpecifier(imported, local); if (typeOnly) specifier.importKind = 'type'; specifiers.push(specifier); } while (this.match(types_1.TokenType.COMMA)); } exportDeclaration() { const exportToken = this.previous(); // `содир = ифода;` (TypeScript `export =`) if (this.match(types_1.TokenType.ASSIGN)) { const expression = this.assignment(); this.consumeSemicolon("Expected ';' after export assignment"); return { type: 'ExportAssignment', expression, line: exportToken.line, column: exportToken.column, }; } // `содир навъ { Т };`, `содир навъ * аз "./м";`: types only const typeOnly = this.isTypeOnlyModifier() && (this.peekNext()?.type === types_1.TokenType.LEFT_BRACE || this.peekNext()?.type === types_1.TokenType.MULTIPLY); if (typeOnly) this.advance(); const kind = typeOnly ? { exportKind: 'type' } : {}; // Handle: содир пешфарз if (this.match(types_1.TokenType.ПЕШФАРЗ)) return this.defaultExport(exportToken); // Handle: содир { name1, name2 } if (this.match(types_1.TokenType.LEFT_BRACE)) return this.namedExports(exportToken, typeOnly); // Handle: содир * аз "module", содир * чун Н аз "module" if (this.match(types_1.TokenType.MULTIPLY)) { let namespaceExport; if (this.match(types_1.TokenType.ЧУН)) { // `содир * чун "а-б" аз "./м";` (ES2022) namespaceExport = this.moduleExportName(this.check(types_1.TokenType.STRING) ? this.advance() : this.parseImportOrExportName("Expected export name after 'чун'")); } this.consume(types_1.TokenType.АЗ, "Expected 'аз' after '*'"); const sourceToken = this.consume(types_1.TokenType.STRING, 'Expected module path'); const source = { type: 'Literal', value: sourceToken.value, raw: `"${sourceToken.value}"`, line: sourceToken.line, column: sourceToken.column, }; this.consumeSemicolon("Expected ';' after export statement"); return { type: 'ExportDeclaration', specifiers: [], source, default: false, ...kind, ...(namespaceExport && { namespaceExport }), line: exportToken.line, column: exportToken.column, }; } // Handle: содир // This includes: функсия, синф, собит, тағйирёбанда, интерфейс, навъ, ҳамзамон функсия // Special handling for async functions if (this.isAsyncWord()) { this.advance(); this.consume(types_1.TokenType.ФУНКСИЯ, "Expected 'функсия' after 'ҳамзамон'"); const func = this.functionDeclaration(); func.async = true; return { type: 'ExportDeclaration', declaration: func, default: false, line: exportToken.line, column: exportToken.column, }; } const declaration = this.exportedStatement(); return { type: 'ExportDeclaration', declaration: declaration, default: false, line: exportToken.line, column: exportToken.column, }; } /** `содир пешфарз `, after `пешфарз`. */ defaultExport(exportToken) { const declaration = this.anonymousDefaultExport() ?? this.exportedStatement(); return { type: 'ExportDeclaration', declaration: declaration, default: true, line: exportToken.line, column: exportToken.column, }; } /** * `содир пешфарз функсия () {}`, `… ҳамзамон функсия* () {}`, * `… [мавҳум] синф [мерос А] {}`, also decorated: a function or class * without a name, as an expression statement (`export default function () {}` * in ES modules, `module.exports.default = …` in CommonJS). Null when the * declaration has a name. */ anonymousDefaultExport() { if (this.check(types_1.TokenType.AT)) { const decorators = this.parseDecorators(); const exported = this.anonymousDefaultExport() ?? this.statement(); return this.decorate(decorators, exported); } const start = this.peek(); let expression; const asyncOffset = this.isAsyncFunctionStart() ? 1 : 0; if (this.check(types_1.TokenType.ФУНКСИЯ) || asyncOffset) { if (!this.isAnonymousFunctionHead(asyncOffset + 1)) return null; this.current += asyncOffset; const func = this.parseFunctionExpression(this.advance()); if (asyncOffset) func.async = true; expression = { ...func, line: start.line, column: start.column }; } else { const abstract = this.checkSequence(types_1.TokenType.МАВҲУМ, types_1.TokenType.СИНФ) ? 1 : 0; if (!this.check(abstract ? types_1.TokenType.МАВҲУМ : types_1.TokenType.СИНФ)) return null; if (!Parser.ANONYMOUS_CLASS_FOLLOWERS.has(this.tokens[this.current + abstract + 1]?.type)) { return null; } this.current += abstract; const classExpression = this.parseClassExpression(this.advance()); if (abstract) classExpression.abstract = true; expression = { ...classExpression, line: start.line, column: start.column }; } return { type: 'ExpressionStatement', expression, line: start.line, column: start.column, }; } /** `функсия` at `offset` has no name: `(`, `<` or `*` and then `(` / `<` follow. */ isAnonymousFunctionHead(offset) { let next = this.tokens[this.current + offset]?.type; if (next === types_1.TokenType.MULTIPLY) next = this.tokens[this.current + offset + 1]?.type; return next === types_1.TokenType.LEFT_PAREN || next === types_1.TokenType.LESS_THAN; } /** The statement after `содир` / `содир пешфарз`; a lone `;` exports nothing. */ exportedStatement() { if (this.check(types_1.TokenType.SEMICOLON)) { throw new Error(this.unexpectedTokenMessage("Expected a declaration after 'содир'")); } return this.statement(); } createExportSpecifier(local, exported) { return { type: 'ExportSpecifier', local: this.moduleExportName(local), exported: this.moduleExportName(exported), line: local.line, column: local.column, }; } /** `содир { а, б чун в };` and `содир { а } аз "./м";`, after the `{`. */ namedExports(exportToken, typeOnly) { const localTokens = []; const specifiers = this.parseExportSpecifiers(localTokens); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after export specifiers"); // Handle: содир { name1, name2 } аз "module" let source; if (this.match(types_1.TokenType.АЗ)) { const sourceToken = this.consume(types_1.TokenType.STRING, 'Expected module path after аз'); source = { type: 'Literal', value: sourceToken.value, raw: `"${sourceToken.value}"`, line: sourceToken.line, column: sourceToken.column, }; } this.consumeSemicolon("Expected ';' after export statement"); // Without `аз`, the specifiers export names of this module if (!source) localTokens.forEach(token => this.checkBindingName(token)); if (typeOnly && specifiers.some(specifier => specifier.exportKind)) { this.errors.push(`The 'навъ' modifier cannot be used on a named export when 'содир навъ' is used on its export statement at line ${exportToken.line}, column ${exportToken.column}`); } return { type: 'ExportDeclaration', specifiers, source, default: false, ...(typeOnly && { exportKind: 'type' }), line: exportToken.line, column: exportToken.column, }; } /** * The specifiers of `содир { … }`; `localTokens` receives the token of each * local name, which must be a name unless `аз "./м"` follows. */ parseExportSpecifiers(localTokens) { const specifiers = []; if (this.check(types_1.TokenType.RIGHT_BRACE)) { return specifiers; } do { // A trailing comma is allowed: `{ а, б, }` if (specifiers.length > 0 && this.check(types_1.TokenType.RIGHT_BRACE)) break; const typeOnly = this.matchSpecifierTypeModifier(); // `{ х чун пешфарз }`, `{ пешфарз } аз "./м"`: export names may be any word const local = this.parseModuleExportName('Expected export name'); localTokens.push(local); let exported = local; if (this.match(types_1.TokenType.ЧУН)) { exported = this.parseModuleExportName("Expected export alias after 'чун'"); } const specifier = this.createExportSpecifier(local, exported); if (typeOnly) specifier.exportKind = 'type'; specifiers.push(specifier); } while (this.match(types_1.TokenType.COMMA)); return specifiers; } matchBuiltinIdentifier() { if (this.isBuiltinIdentifierType(this.peek().type)) { this.advance(); return true; } return false; } isBuiltinIdentifierType(type) { return Parser.BUILTIN_IDENTIFIER_TYPES.has(type); } /** Tokens usable as a plain identifier (variable or parameter name). */ isPlainIdentifierToken(token) { return (token.type === types_1.TokenType.IDENTIFIER || this.isBuiltinIdentifierType(token.type) || token.type === types_1.TokenType.НАВЪ || token.type === types_1.TokenType.МАЪЛУМОТ || token.type === types_1.TokenType.РӮЙХАТ || token.type === types_1.TokenType.БЕҚИМАТ); } arrayExpression() { const leftBracket = this.previous(); const elements = []; while (!this.check(types_1.TokenType.RIGHT_BRACKET)) { // A hole: `[1, , 3]` if (this.match(types_1.TokenType.COMMA)) { elements.push(null); continue; } elements.push(this.spreadOrAssignment()); if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after array elements"); return { type: 'ArrayExpression', elements, line: leftBracket.line, column: leftBracket.column, }; } objectExpression() { const leftBrace = this.previous(); const properties = []; while (!this.check(types_1.TokenType.RIGHT_BRACE)) { if (this.check(types_1.TokenType.SPREAD)) { properties.push(this.spreadOrAssignment()); } else { properties.push(this.parseProperty()); } if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after object properties"); return { type: 'ObjectExpression', properties, line: leftBrace.line, column: leftBrace.column, }; } /** * `ҳамзамон ном() {…}`, `*ном() {…}`, `ҳамзамон *ном() {…}` in an object * literal — unless `ҳамзамон` is itself the key. */ parseObjectMethodModifiers() { const isAsync = this.isAsyncWord() && this.modifierApplies() && !!this.advance(); return { isAsync, generator: this.match(types_1.TokenType.MULTIPLY) }; } /** Parameters, return type and body of an object literal method, after its '('. */ objectMethod(startToken, modifiers) { const { params, thisType } = this.withGenerator(false, () => this.parseParametersWithThis("Expected ')' after method parameters")); let returnType; if (this.match(types_1.TokenType.COLON)) { returnType = this.returnTypeAnnotation(); } this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' before method body"); const body = this.withGenerator(modifiers.generator, () => this.blockStatement()); return { type: 'FunctionExpression', params, body, returnType, ...(modifiers.isAsync && { async: true }), ...(modifiers.generator && { generator: true }), ...(thisType && { thisType }), line: startToken.line, column: startToken.column, }; } parseProperty() { const startToken = this.peek(); // `{ get ном() { … }, set ном(қ) { … } }` const accessor = this.parseAccessorKind(); let key; let computed = false; const modifiers = this.parseObjectMethodModifiers(); if (this.match(types_1.TokenType.LEFT_BRACKET)) { // Computed property key = this.assignment(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property name"); computed = true; } else if (this.match(types_1.TokenType.STRING)) { key = this.createLiteral(this.previous().value, this.previous()); } else if (this.match(types_1.TokenType.NUMBER)) { this.checkBigIntName(this.previous()); key = this.createNumericLiteral(this.previous()); } else if (this.isIdentifierNameToken(this.peek())) { // Keywords can be used as property names key = this.createIdentifier(this.advance()); } else { throw new Error(this.unexpectedTokenMessage('Expected property name')); } const property = { type: 'Property', key, value: key, computed, shorthand: false, line: startToken.line, column: startToken.column, }; // A generic method's type parameters: `{ ҳамон<Т>(х: Т): Т { … } }` const typeParameters = this.parseTypeParameters(); if (this.match(types_1.TokenType.LEFT_PAREN)) { this.parseMethodShorthand(property, startToken, accessor, modifiers); if (typeParameters) property.value.typeParameters = typeParameters; return property; } if (modifiers.isAsync || modifiers.generator) { throw new Error(this.unexpectedTokenMessage("Expected '(' after method name")); } if (this.match(types_1.TokenType.COLON)) { property.value = this.assignment(); return property; } if (!computed && key.type === 'Identifier' && this.isPlainIdentifierToken(startToken)) { return this.parseShorthandProperty(property, startToken); } throw new Error(this.unexpectedTokenMessage("Expected ':' after property key")); } /** * `{ ном }`, which stands for `{ ном: ном }`, or `{ ном = 1 }`: a default, * if the object turns out to be a destructuring assignment target. */ parseShorthandProperty(property, name) { property.shorthand = true; if (this.check(types_1.TokenType.COMMA) || this.check(types_1.TokenType.RIGHT_BRACE)) { property.value = this.createIdentifier(name); return property; } const at = this.consume(types_1.TokenType.ASSIGN, "Expected ':' after property key"); property.value = { type: 'AssignmentExpression', left: this.createIdentifier(name), operator: '=', right: this.assignment(), line: name.line, column: name.column, }; this.coverInitializers = [...this.coverInitializers, { property, at }]; return property; } /** Method shorthand `{ ном() { … } }` or accessor `{ get ном() { … } }`, after its '('. */ parseMethodShorthand(property, startToken, accessor, modifiers) { const method = this.objectMethod(startToken, modifiers); property.value = method; property.method = true; if (accessor) { property.kind = accessor; this.checkAccessorParams(accessor, method, startToken); } return property; } tryStatement() { const tryToken = this.previous(); // Consume the opening brace for try block this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after 'кӯшиш'"); const block = this.blockStatement(); let handler = undefined; if (this.match(types_1.TokenType.ГИРИФТАН)) { let param; let typeAnnotation; // The binding is optional, as in `catch { … }` (ES2019). if (this.match(types_1.TokenType.LEFT_PAREN)) { // A name or, as in JavaScript, a pattern: `гирифтан ({ message })` param = this.parsePattern(); if (this.match(types_1.TokenType.COLON)) { typeAnnotation = this.typeAnnotation(); this.checkCatchType(typeAnnotation); } this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after catch parameter"); } this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after catch clause"); const body = this.blockStatement(); handler = { type: 'CatchClause', param, ...(typeAnnotation && { typeAnnotation }), body, line: this.previous().line, column: this.previous().column, }; } let finalizer = undefined; if (this.match(types_1.TokenType.НИҲОЯТ)) { this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after 'ниҳоят'"); finalizer = this.blockStatement(); } // As in JavaScript (and TypeScript's TS1472): `try { }` alone is a syntax error if (!handler && !finalizer) { throw new Error(this.unexpectedTokenMessage("Expected 'гирифтан' or 'ниҳоят' after 'кӯшиш'")); } return { type: 'TryStatement', block, handler, finalizer, line: tryToken.line, column: tryToken.column, }; } /** TypeScript's TS1196: a catch binding is typed only `ношинос` or `ҳар` (`unknown`, `any`). */ checkCatchType(annotation) { const type = annotation.typeAnnotation; const name = type.type === 'PrimitiveType' ? type.name : type.type === 'GenericType' && !type.typeParameters ? type.name.name : undefined; if (name && ['ҳар', 'ношинос', 'any', 'unknown'].includes(name)) return; this.errors.push(`Catch clause variable type annotation must be 'ҳар' or 'ношинос' if specified at line ${type.line}, column ${type.column}`); } throwStatement() { const throwToken = this.previous(); const argument = this.expression(); this.consumeSemicolon("Expected ';' after throw statement"); return { type: 'ThrowStatement', argument, line: throwToken.line, column: throwToken.column, }; } /** * Parses parameters after a consumed '(' up to and including the closing ')'. * `allowProperties`: a constructor, whose parameters may be parameter properties. */ /** * Parameters of a function or method that may start with a `this` * parameter, `(ин: Т, х: рақам)`: its type is returned apart, since it is * not a parameter at run time. */ parseParametersWithThis(closeMessage, allowDecorators = false) { let thisType; if (this.checkSequence(types_1.TokenType.ИН, types_1.TokenType.COLON)) { this.advance(); // 'ин' this.advance(); // ':' thisType = this.typeAnnotation(); if (!this.check(types_1.TokenType.RIGHT_PAREN)) { this.consume(types_1.TokenType.COMMA, "Expected ',' after the 'ин' parameter"); } } const params = this.parseParameterList(closeMessage, false, allowDecorators); return { params, ...(thisType && { thisType }) }; } parseParameterList(closeMessage, allowProperties = false, allowDecorators = allowProperties) { const params = []; while (!this.check(types_1.TokenType.RIGHT_PAREN)) { const decorators = this.parseDecorators(); if (decorators.length > 0 && !allowDecorators) this.reportInvalidDecorators(decorators); const param = this.parseParameter(allowProperties); if (decorators.length > 0) param.decorators = decorators; params.push(param); if (param.rest && !this.check(types_1.TokenType.RIGHT_PAREN)) { throw new Error(`Rest parameter must be last at line ${this.peek().line}, column ${this.peek().column}`); } if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_PAREN, closeMessage); return params; } parseParameter(allowProperties) { const modifiers = this.parseParameterModifiers(allowProperties); const rest = this.match(types_1.TokenType.SPREAD); const startToken = this.peek(); let name; let pattern; if (this.check(types_1.TokenType.LEFT_BRACKET) || this.check(types_1.TokenType.LEFT_BRACE)) { pattern = this.parsePattern(); // Synthetic name; codegen emits `pattern` in its place name = { type: 'Identifier', name: `__param${this.patternCounter++}`, line: startToken.line, column: startToken.column, }; } else if (this.check(types_1.TokenType.IDENTIFIER) || this.matchBuiltinIdentifier() || this.match(types_1.TokenType.НАВЪ, types_1.TokenType.МАЪЛУМОТ, types_1.TokenType.РӮЙХАТ, types_1.TokenType.БЕҚИМАТ)) { // Common Tajik words are allowed as parameter names name = this.createIdentifier(this.check(types_1.TokenType.IDENTIFIER) ? this.advance() : this.previous()); } else { throw new Error(`Expected parameter name at line ${startToken.line}, column ${startToken.column}`); } // Parse optional indicator const optional = this.match(types_1.TokenType.QUESTION); // Parse optional type annotation let typeAnnotation; if (this.match(types_1.TokenType.COLON)) { typeAnnotation = this.typeAnnotation(); } let defaultValue; if (this.match(types_1.TokenType.ASSIGN)) { if (rest) { throw new Error(`Rest parameter cannot have a default value at line ${this.previous().line}, column ${this.previous().column}`); } defaultValue = this.assignment(); } const param = { type: 'Parameter', name, typeAnnotation, optional, line: startToken.line, column: startToken.column, ...modifiers, }; if (defaultValue) param.defaultValue = defaultValue; if (rest) param.rest = true; if (pattern) param.pattern = pattern; return param; } /** A parameter property modifier, `бознавис` / `override` included. */ parameterModifier(token) { if (token.type === types_1.TokenType.IDENTIFIER && Parser.OVERRIDE_KEYWORDS.has(token.value)) { return 'override'; } return Parser.PARAMETER_MODIFIERS.get(token.type); } /** * Modifiers of a parameter property: `[ҷамъиятӣ|хосусӣ|муҳофизатшуда] [бознавис] [танҳохонӣ]`. * They are modifiers only when a parameter follows (`хосусӣ х`); otherwise * (`(хосусӣ: рақам)`) the word is the parameter's name. */ parseParameterModifiers(allowProperties) { const result = {}; const first = this.peek(); let modifier = this.parameterModifier(first); while (modifier && this.startsParameterAfterModifier(this.peekNext())) { const token = this.advance(); const at = `at line ${token.line}, column ${token.column}`; if (!allowProperties) { throw new Error(`A parameter property is only allowed in a constructor ${at}`); } const seen = modifier === 'readonly' ? result.readonly : modifier === 'override' ? result.override : result.accessibility; if (seen) { throw new Error(`Duplicate modifier '${token.value}' ${at}`); } if (modifier === 'readonly') { result.readonly = true; } else if (result.readonly) { throw new Error(`'${token.value}' modifier must precede 'танҳохонӣ' modifier ${at}`); } else if (modifier === 'override') { result.override = true; } else if (result.override) { throw new Error(`'${token.value}' modifier must precede 'бознавис' modifier ${at}`); } else { result.accessibility = modifier; } modifier = this.parameterModifier(this.peek()); } if (first !== this.peek() && !this.isPlainIdentifierToken(this.peek())) { throw new Error(`A parameter property cannot be a rest parameter or a destructuring pattern at line ${first.line}, column ${first.column}`); } return result; } startsParameterAfterModifier(token) { return (token !== undefined && (this.isPlainIdentifierToken(token) || token.type === types_1.TokenType.SPREAD || token.type === types_1.TokenType.LEFT_BRACKET || token.type === types_1.TokenType.LEFT_BRACE)); } typeAnnotation() { const typeNode = this.parseType(); return { type: 'TypeAnnotation', typeAnnotation: typeNode, line: typeNode.line, column: typeNode.column, }; } /** A return type annotation: a type, a type predicate or an assertion signature. */ returnTypeAnnotation() { const typeNode = this.parseReturnType(); return { type: 'TypeAnnotation', typeAnnotation: typeNode, line: typeNode.line, column: typeNode.column, }; } parseReturnType() { return this.parseTypePredicate() ?? this.parseType(); } /** * `х аст Т` / `ин аст Т` (`x is T`), `тасдиқ х` / `тасдиқ х аст Т` * (`asserts x [is T]`). `аст`, `тасдиқ` and their English spellings `is`, * `asserts` are keywords only here. */ parseTypePredicate() { const start = this.peek(); const asserts = this.isAssertsModifier(); const subjectIndex = this.current + (asserts ? 1 : 0); const isPredicate = this.isPredicateSubject(this.tokens[subjectIndex]) && this.isPredicateKeyword(this.tokens[subjectIndex + 1]); if (!asserts && !isPredicate) return undefined; if (asserts) this.advance(); const subject = this.advance(); const parameterName = subject.type === types_1.TokenType.ИН ? { type: 'ThisType', line: subject.line, column: subject.column } : this.createIdentifier(subject); let typeAnnotation; if (isPredicate) { this.advance(); // 'аст' typeAnnotation = this.parseType(); } return { type: 'TypePredicate', parameterName, ...(typeAnnotation && { typeAnnotation }), asserts, line: start.line, column: start.column, }; } /** `тасдиқ`/`asserts` followed, on the same line, by a parameter name or `ин`. */ isAssertsModifier() { const token = this.peek(); const next = this.peekNext(); const isWord = token.type === types_1.TokenType.ТАСДИҚ || (token.type === types_1.TokenType.IDENTIFIER && token.value === 'asserts'); if (!isWord || !next || next.line !== token.line) return false; // `тасдиқ аст Т` is a predicate on a parameter named `тасдиқ` return this.isPredicateSubject(next) && !this.isPredicateKeyword(next); } isPredicateSubject(token) { return (token !== undefined && (token.type === types_1.TokenType.ИН || this.isPlainIdentifierToken(token))); } isPredicateKeyword(token) { return (token?.type === types_1.TokenType.АСТ || (token?.type === types_1.TokenType.IDENTIFIER && token.value === 'is')); } parseType() { return this.conditionalType(); } conditionalType() { const type = this.unionType(); // Handle conditional types: T мерос constraint ? trueType : falseType if (this.match(types_1.TokenType.МЕРОС)) { const constraint = this.unionType(); if (!this.match(types_1.TokenType.QUESTION)) { this.errors.push(`Expected '?' in conditional type at line ${this.peek().line}, column ${this.peek().column}`); return type; } const trueType = this.unionType(); if (!this.match(types_1.TokenType.COLON)) { this.errors.push(`Expected ':' in conditional type at line ${this.peek().line}, column ${this.peek().column}`); return type; } const falseType = this.conditionalType(); // Right-associative for nested conditionals return { type: 'ConditionalType', checkType: type, extendsType: constraint, trueType, falseType, line: type.line, column: type.column, }; } return type; } /** `А | Б`; as in TypeScript a `|` may lead: `| "а" | "б"` (handy across lines). */ unionType() { const leading = this.match(types_1.TokenType.BITWISE_OR) ? this.previous() : undefined; const type = this.intersectionType(); if (!this.check(types_1.TokenType.BITWISE_OR)) return type; const types = [type]; while (this.match(types_1.TokenType.BITWISE_OR)) { types.push(this.intersectionType()); } const start = leading ?? type; return { type: 'UnionType', types, line: start.line, column: start.column }; } /** `А & Б`; a leading `&` is allowed, as in TypeScript: `& А & Б`. */ intersectionType() { const leading = this.match(types_1.TokenType.BITWISE_AND) ? this.previous() : undefined; const type = this.primaryType(); if (!this.check(types_1.TokenType.BITWISE_AND)) return type; const types = [type]; while (this.match(types_1.TokenType.BITWISE_AND)) { types.push(this.primaryType()); } const start = leading ?? type; return { type: 'IntersectionType', types, line: start.line, column: start.column, }; } primaryType() { let type = this.primaryTypeOperand(); // Postfix forms: array `Т[]` and indexed access `Т[К]`, on the line of `Т` while (!this.hasLineBreakBefore() && this.match(types_1.TokenType.LEFT_BRACKET)) { if (this.match(types_1.TokenType.RIGHT_BRACKET)) { type = { type: 'ArrayType', elementType: type, line: type.line, column: type.column, }; } else { const indexType = this.parseType(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after index type"); type = { type: 'IndexedAccessType', objectType: type, indexType, line: type.line, column: type.column, }; } } return type; } /** A type without the `[]` or `[К]` after it. */ primaryTypeOperand() { return (this.parseGenericFunctionType() ?? this.parseImportType() ?? this.parseParenthesizedOrArrayType() ?? this.parseConstructorType() ?? this.parseReadonlyType() ?? this.parseThisType() ?? this.parseUniqueType() ?? this.parseKeyofType() ?? this.parseLiteralType() ?? this.parsePrimitiveType() ?? this.parseGenericOrIdentifierType() ?? this.parseTupleType() ?? this.parseObjectType() ?? this.errorExpectedType()); } /** `калидҳои Т` (keyof) */ parseKeyofType() { if (!this.match(types_1.TokenType.КАЛИДҲОИ)) return undefined; const keyofToken = this.previous(); return { type: 'KeyofType', operand: this.primaryType(), line: keyofToken.line, column: keyofToken.column, }; } parseParenthesizedOrArrayType() { if (!this.check(types_1.TokenType.LEFT_PAREN)) return undefined; if (this.isFunctionTypeStart()) return this.parseFunctionType(); this.advance(); const type = this.parseType(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after type"); return type; } /** At `(`: does the matching `)` precede `=>`? Then this is a function type. */ isFunctionTypeStart() { let depth = 0; for (let i = this.current; i < this.tokens.length; i++) { const type = this.tokens[i].type; if (type === types_1.TokenType.LEFT_PAREN) depth++; else if (type === types_1.TokenType.RIGHT_PAREN && --depth === 0) { return this.tokens[i + 1].type === types_1.TokenType.ARROW; } } // No matching `)` before the end return false; } /** `(а: рақам, ...б: сатр[]) => мантиқӣ`, at the `(`; `typeParameters` came before it. */ parseFunctionType(typeParameters, start) { const openParen = this.advance(); const { params: parameters, thisType } = this.parseParametersWithThis("Expected ')' after function type parameters"); this.consume(types_1.TokenType.ARROW, "Expected '=>' in function type"); const position = start ?? openParen; return { type: 'FunctionType', ...(typeParameters && { typeParameters }), parameters, returnType: this.parseReturnType(), ...(thisType && { thisType: thisType.typeAnnotation }), line: position.line, column: position.column, }; } /** A generic function type: `<Т>(х: Т) => Т`. */ parseGenericFunctionType() { if (!this.check(types_1.TokenType.LESS_THAN)) return undefined; const start = this.peek(); const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); if (!this.check(types_1.TokenType.LEFT_PAREN)) { throw new Error(this.unexpectedTokenMessage("Expected '(' after type parameters")); } return this.parseFunctionType(typeParameters, start); } /** * `ворид("./м")`, `ворид("./м").Т<У>` (TypeScript `import("./m").T`) and, * after `навъи`, `навъи ворид("./м")`: types of another module. */ parseImportType(isTypeOf = false, start = this.peek()) { if (!this.checkSequence(types_1.TokenType.ВОРИД, types_1.TokenType.LEFT_PAREN)) return undefined; this.advance(); // 'ворид' this.advance(); // '(' const source = this.consume(types_1.TokenType.STRING, 'Expected a module path in an import type'); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after the module path"); const names = []; while (this.match(types_1.TokenType.DOT)) { names.push(this.parsePropertyName("Expected a name after '.'").name); } const typeArguments = !isTypeOf && this.check(types_1.TokenType.LESS_THAN) ? this.parseTypeArgumentList() : undefined; return { type: 'ImportType', argument: this.createLiteral(source.value, source), ...(names.length > 0 && { qualifier: names.join('.') }), ...(typeArguments && { typeArguments }), ...(isTypeOf && { isTypeOf }), line: start.line, column: start.column, }; } /** `нав (а: рақам) => Т`, `нав <Т>(а: Т) => Т`, `мавҳум нав () => Т` */ parseConstructorType() { const isAbstract = this.checkSequence(types_1.TokenType.МАВҲУМ, types_1.TokenType.НАВ); if (!isAbstract && !this.check(types_1.TokenType.НАВ)) return undefined; const start = this.advance(); if (isAbstract) this.advance(); // 'нав' const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'нав' in constructor type"); const parameters = this.parseParameterList("Expected ')' after constructor type parameters"); this.consume(types_1.TokenType.ARROW, "Expected '=>' in constructor type"); return { type: 'ConstructorType', ...(typeParameters && { typeParameters }), parameters, returnType: this.parseType(), ...(isAbstract && { abstract: true }), line: start.line, column: start.column, }; } /** `танҳохонӣ рақам[]`, `танҳохонӣ [рақам, сатр]`; a bare `танҳохонӣ` stays a type name. */ parseReadonlyType() { const next = this.peekNext(); if (!this.check(types_1.TokenType.ТАНҲОХОНӢ) || !next || Parser.TYPE_FOLLOWERS.has(next.type)) { return undefined; } const readonlyToken = this.advance(); const typeAnnotation = this.primaryType(); // TypeScript's TS1354: not `танҳохонӣ сатр`, nor `танҳохонӣ Array<сатр>` if (typeAnnotation.type !== 'ArrayType' && typeAnnotation.type !== 'TupleType') { this.errors.push(`'танҳохонӣ' type modifier is only permitted on array and tuple types at line ${readonlyToken.line}, column ${readonlyToken.column}`); } return { type: 'ReadonlyType', typeAnnotation, line: readonlyToken.line, column: readonlyToken.column, }; } /** `ин` as a type: `илова(): ин` */ parseThisType() { if (!this.match(types_1.TokenType.ИН)) return undefined; const token = this.previous(); return { type: 'ThisType', line: token.line, column: token.column }; } parseUniqueType() { if (!this.match(types_1.TokenType.БЕНАЗИР)) return undefined; const uniqueToken = this.previous(); const baseType = this.primaryType(); const uniqueType = { type: 'UniqueType', baseType, line: uniqueToken.line, column: uniqueToken.column, }; return uniqueType; } parseLiteralType() { // Parse string literals in types (e.g., "фъало" in union types) if (this.check(types_1.TokenType.STRING)) { const token = this.advance(); return { type: 'LiteralType', value: token.value, line: token.line, column: token.column, }; } // Parse number literals in types (e.g., 1 | 2 in union types), also negative ones (`-1`) if (this.check(types_1.TokenType.NUMBER) || this.checkSequence(types_1.TokenType.MINUS, types_1.TokenType.NUMBER)) { const start = this.peek(); const negative = this.match(types_1.TokenType.MINUS); const token = this.advance(); const literal = this.createNumericLiteral(token); return { type: 'LiteralType', value: negative ? -literal.value : literal.value, ...(literal.raw.endsWith('n') && { bigint: true }), line: start.line, column: start.column, }; } // A template literal type: `пеш_${К}` if (this.match(types_1.TokenType.TEMPLATE_LITERAL)) { return this.parseTemplateLiteralType(this.previous()); } // Parse boolean literals in types (e.g., true | false) if (this.match(types_1.TokenType.ДУРУСТ, types_1.TokenType.НОДУРУСТ)) { const token = this.previous(); return { type: 'LiteralType', value: token.type === types_1.TokenType.ДУРУСТ, line: token.line, column: token.column, }; } return undefined; } /** `` `пеш_${К}-${рақам}` ``: each `${…}` holds a type, parsed by a sub-parser. */ parseTemplateLiteralType(token) { const quasis = []; const types = []; for (const part of this.splitTemplate(token.value)) { if (part.type === 'text') { quasis.push(part.value); } else { const { line, column } = this.templateOffsetPosition(token, part.offset); types.push(this.parseSubSource(part.value, line, column, sub => sub.parseType(), "Expected '}' after template type")); } } return { type: 'TemplateLiteralType', quasis, types, line: token.line, column: token.column }; } parsePrimitiveType() { if (!this.match(types_1.TokenType.САТР, types_1.TokenType.РАҚАМ, types_1.TokenType.МАНТИҚӢ, types_1.TokenType.ХОЛӢ, types_1.TokenType.БЕҚИМАТ, types_1.TokenType.ҲАР, types_1.TokenType.НОШИНОС, types_1.TokenType.АБАДАН, types_1.TokenType.БЕДЖАВОБ, types_1.TokenType.ОБЪЕКТ, types_1.TokenType.РАМЗ, types_1.TokenType.КАЛОНРАҚАМ)) { return undefined; } const token = this.previous(); const primitiveType = { type: 'PrimitiveType', // `null` is read as `холӣ` name: (token.type === types_1.TokenType.ХОЛӢ ? 'холӣ' : token.value), line: token.line, column: token.column, }; return primitiveType; } /** * `навъи х` / `typeof х` (TypeQuery) and `инфер У` / `infer У` (InferType): * the word is a type operator only when a name follows on its line. */ parseTypeQueryOrInfer() { const token = this.peek(); const next = this.peekNext(); const word = Parser.typeOperatorWord(token); if (!word || !next || next.line !== token.line) return undefined; // `навъи ворид("./м")` const isImport = next.type === types_1.TokenType.ВОРИД && this.tokens[this.current + 2]?.type === types_1.TokenType.LEFT_PAREN; if (word === 'query' && isImport) { this.advance(); return this.parseImportType(true, token); } if (!this.isTypeNameToken(next)) return undefined; this.advance(); const nameToken = this.advance(); return word === 'infer' ? this.inferType(token, nameToken) : this.typeQuery(token, nameToken); } /** `навъи`/`typeof` starts a type query, `инфер`/`infer` an infer type. */ static typeOperatorWord(token) { if (token.type === types_1.TokenType.НАВЪИ) return 'query'; if (token.type === types_1.TokenType.ИНФЕР) return 'infer'; if (token.type !== types_1.TokenType.IDENTIFIER) return undefined; if (token.value === 'typeof') return 'query'; return token.value === 'infer' ? 'infer' : undefined; } /** `инфер У`, `инфер У мерос сатр`: after the name. */ inferType(inferToken, nameToken) { return { type: 'InferType', typeParameter: { type: 'TypeParameter', name: this.createIdentifier(nameToken), ...this.parseInferConstraint(), line: nameToken.line, column: nameToken.column, }, line: inferToken.line, column: inferToken.column, }; } /** `навъи х`, `навъи о.а.б`, `навъи ф<рақам>`: after the first name. */ typeQuery(queryToken, nameToken) { // `навъи о.а.б`: a dotted value name, whose members may be named with keywords let name = nameToken.value; while (this.check(types_1.TokenType.DOT) && this.peekNext() && this.isIdentifierNameToken(this.peekNext())) { this.advance(); name += `.${this.advance().value}`; } // `навъи ф<рақам>`: the type of an instantiation expression (TypeScript 4.7) const typeArguments = this.check(types_1.TokenType.LESS_THAN) && !this.hasLineBreakBefore() ? (this.speculateCleanly(() => this.parseTypeArgumentList()) ?? undefined) : undefined; return { type: 'TypeQuery', exprName: { type: 'Identifier', name, line: nameToken.line, column: nameToken.column }, ...(typeArguments && { typeArguments }), line: queryToken.line, column: queryToken.column, }; } /** * `инфер У мерос сатр` (TypeScript 4.7): a constraint, unless a `?` follows * it, when the `мерос` starts a conditional type around the `инфер`. */ parseInferConstraint() { if (!this.check(types_1.TokenType.МЕРОС)) return {}; const constraint = this.speculate(() => { this.advance(); // 'мерос' const type = this.unionType(); return this.check(types_1.TokenType.QUESTION) ? undefined : type; }); return constraint ? { constraint } : {}; } /** A name in a type: an identifier, a contextual keyword, or `ин`. */ isTypeNameToken(token) { return (token.type === types_1.TokenType.IDENTIFIER || token.type === types_1.TokenType.ИН || this.isBuiltinIdentifierType(token.type)); } parseGenericOrIdentifierType() { const operator = this.parseTypeQueryOrInfer(); if (operator) return operator; // Allow certain keywords to be used as type names if (!this.check(types_1.TokenType.IDENTIFIER) && !this.matchBuiltinIdentifier() && // `Ваъда<Т>` (a builtin identifier) is the Promise type !this.match(types_1.TokenType.ФУНКСИЯ)) { return undefined; } const nameToken = this.check(types_1.TokenType.IDENTIFIER) ? this.advance() : this.previous(); // Build the full name, handling qualified types like Foo.Bar let fullName = nameToken.value; // Handle qualified type names (e.g., Namespace.Type), whose parts may be any word while (this.match(types_1.TokenType.DOT)) { if (this.isIdentifierNameToken(this.peek())) { const nextToken = this.advance(); fullName += '.' + nextToken.value; } else { // If we can't parse what comes after the dot, treat it as an error this.errors.push(`Expected type name after '.' at line ${this.peek().line}`); break; } } const name = { type: 'Identifier', name: fullName, line: nameToken.line, column: nameToken.column, }; let typeParameters; if (this.match(types_1.TokenType.LESS_THAN)) { typeParameters = []; do { typeParameters.push(this.parseType()); } while (this.match(types_1.TokenType.COMMA)); this.consumeTypeArgumentsClose(); } const genericType = { type: 'GenericType', name, typeParameters, line: name.line, column: name.column, }; return genericType; } /** * The label of a named tuple member (`[х: рақам, у?: рақам]`), which may be * any word; `optional` for `у?:`. */ parseTupleMemberLabel() { if (!this.isIdentifierNameToken(this.peek())) return { optional: false }; const optional = this.peekNext()?.type === types_1.TokenType.QUESTION; if (this.tokens[this.current + (optional ? 2 : 1)]?.type !== types_1.TokenType.COLON) { return { optional: false }; } const label = this.createIdentifier(this.advance()); this.current += optional ? 2 : 1; return { label, optional }; } /** A tuple element: `Т`, optional `Т?` / `н?: Т`, or rest `...Т[]` / `...н: Т[]`. */ parseTupleElement() { const spread = this.match(types_1.TokenType.SPREAD) ? this.previous() : undefined; const { label, optional: optionalLabel } = this.parseTupleMemberLabel(); // Any type, a conditional one too: `[Т мерос сатр ? 1 : 2]` const elementType = this.parseType(); if (spread) { const rest = { type: 'RestType', typeAnnotation: elementType, line: spread.line, column: spread.column, }; return { type: rest, label }; } const optionalType = !optionalLabel && this.check(types_1.TokenType.QUESTION) ? this.advance() : undefined; if (label && optionalType) { // TypeScript's TS5086: the `?` of a named member goes after the name this.errors.push(`A labeled tuple element is declared as optional with a question mark after the name and before the colon, rather than after the type at line ${optionalType.line}, column ${optionalType.column}`); } if (!optionalLabel && !optionalType) return { type: elementType, label }; const optional = { type: 'OptionalType', typeAnnotation: elementType, line: elementType.line, column: elementType.column, }; return { type: optional, label }; } parseTupleType() { if (!this.match(types_1.TokenType.LEFT_BRACKET)) return undefined; const open = this.previous(); const elements = []; if (!this.check(types_1.TokenType.RIGHT_BRACKET)) { do { elements.push(this.parseTupleElement()); } while (this.match(types_1.TokenType.COMMA)); } this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after tuple types"); const labels = elements.filter(element => element.label).length; if (labels > 0 && labels < elements.length) { // TypeScript's TS5084 this.errors.push(`Tuple members must all have names or all not have names at line ${open.line}, column ${open.column}`); } const tupleType = { type: 'TupleType', elementTypes: elements.map(element => element.type), ...(labels === elements.length && labels > 0 && { elementNames: elements.map(element => element.label) }), line: open.line, column: open.column, }; return tupleType; } parseObjectType() { if (!this.match(types_1.TokenType.LEFT_BRACE)) return undefined; const leftBrace = this.previous(); if (this.isMappedTypeStart()) { return this.parseMappedType(leftBrace); } const properties = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { properties.push(this.propertySignature()); } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after object type properties"); return { type: 'ObjectType', properties, line: leftBrace.line, column: leftBrace.column, }; } /** After '{': `[танҳохонӣ] [К дар …]` starts a mapped type. */ isMappedTypeStart() { let index = this.current; if (this.tokens[index]?.type === types_1.TokenType.PLUS || this.tokens[index]?.type === types_1.TokenType.MINUS) { index++; } if (this.tokens[index]?.type === types_1.TokenType.ТАНҲОХОНӢ) index++; return (this.tokens[index]?.type === types_1.TokenType.LEFT_BRACKET && this.tokens[index + 1] !== undefined && this.isPlainIdentifierToken(this.tokens[index + 1]) && this.tokens[index + 2]?.type === types_1.TokenType.ДАР); } /** * `{ [+|-]танҳохонӣ [К дар Т чун Н]+?|-?: Х }` — types are erased, so `+`/`-` * only parse. */ parseMappedType(leftBrace) { const removesReadonly = this.match(types_1.TokenType.MINUS); const addsReadonly = !removesReadonly && this.match(types_1.TokenType.PLUS); const hasReadonly = this.match(types_1.TokenType.ТАНҲОХОНӢ); const readonly = hasReadonly && !removesReadonly; let readonlyModifier; if (hasReadonly && (removesReadonly || addsReadonly)) { readonlyModifier = removesReadonly ? '-' : '+'; } this.consume(types_1.TokenType.LEFT_BRACKET, "Expected '[' in mapped type"); const nameToken = this.advance(); this.consume(types_1.TokenType.ДАР, "Expected 'дар' in mapped type"); const constraint = this.parseType(); // Key remapping (TypeScript `as`): `[К дар калидҳои Т чун Н]` let nameType; if (this.check(types_1.TokenType.ЧУН) || this.checkIdentifierValue('as')) { this.advance(); nameType = this.parseType(); } this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' in mapped type"); let optional = false; let optionalModifier; if (this.match(types_1.TokenType.MINUS)) { this.consume(types_1.TokenType.QUESTION, "Expected '?' after '-' in mapped type"); optionalModifier = '-'; } else { if (this.match(types_1.TokenType.PLUS)) optionalModifier = '+'; optional = this.match(types_1.TokenType.QUESTION); } this.consume(types_1.TokenType.COLON, "Expected ':' in mapped type"); const typeAnnotation = this.typeAnnotation(); this.match(types_1.TokenType.SEMICOLON, types_1.TokenType.COMMA); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after mapped type"); return { type: 'MappedType', typeParameter: { type: 'TypeParameter', name: this.createIdentifier(nameToken), constraint, line: nameToken.line, column: nameToken.column, }, typeAnnotation, optional, readonly, ...(nameType && { nameType }), ...(readonlyModifier && { readonlyModifier }), ...(optionalModifier && { optionalModifier }), line: leftBrace.line, column: leftBrace.column, }; } /** Consumes one '>' closing type arguments, splitting a `>>` / `>>>` token if needed. */ consumeTypeArgumentsClose(message = "Expected '>' after type parameters") { const token = this.peek(); if (token.type === types_1.TokenType.RIGHT_SHIFT || token.type === types_1.TokenType.UNSIGNED_RIGHT_SHIFT) { const rest = token.value.slice(1); this.tokenSplits?.push({ index: this.current, token }); this.tokens.splice(this.current, 1, { ...token, type: types_1.TokenType.GREATER_THAN, value: '>' }, { ...token, type: rest === '>' ? types_1.TokenType.GREATER_THAN : types_1.TokenType.RIGHT_SHIFT, value: rest, column: token.column + 1, }); } this.consume(types_1.TokenType.GREATER_THAN, message); } errorExpectedType() { throw new Error(`Expected type at line ${this.peek().line}, column ${this.peek().column}`); } /** `<Т, К мерос калидҳои Т = Т>` */ parseTypeParameters() { if (!this.match(types_1.TokenType.LESS_THAN)) { return undefined; } const typeParameters = []; do { // A trailing comma is allowed: `<Т,>(х: Т) => х` if (typeParameters.length > 0 && this.check(types_1.TokenType.GREATER_THAN)) break; const start = this.peek(); const modifiers = this.parseTypeParameterModifiers(); const paramName = this.parseImportOrExportName('Expected type parameter name'); const typeParameter = { type: 'TypeParameter', name: this.createIdentifier(paramName), ...modifiers, line: start.line, column: start.column, }; // `мерос` or, as in TypeScript, `extends` (read as `мерос`) if (this.match(types_1.TokenType.МЕРОС)) { typeParameter.constraint = this.parseType(); } if (this.match(types_1.TokenType.ASSIGN)) { typeParameter.default = this.parseType(); } typeParameters.push(typeParameter); } while (this.match(types_1.TokenType.COMMA)); this.consumeTypeArgumentsClose(); return typeParameters; } /** * `собит` (const), `дар` (in) and `берун` (out) before a type parameter name, * as in TypeScript ``, `` (the English words work too). * Each is a modifier only when a name follows; `<берун>` names the parameter. */ parseTypeParameterModifiers() { const modifiers = {}; // eslint-disable-next-line no-constant-condition while (true) { const token = this.peek(); const modifier = this.typeParameterModifier(token); const next = this.peekNext(); if (!modifier || !next || !this.startsTypeParameter(next)) return modifiers; modifiers[modifier] = true; this.advance(); } } typeParameterModifier(token) { if (token.type === types_1.TokenType.СОБИТ) return 'const'; if (token.type === types_1.TokenType.ДАР) return 'in'; if (token.type !== types_1.TokenType.IDENTIFIER) return undefined; return Parser.TYPE_PARAMETER_MODIFIER_WORDS.get(token.value); } /** A type parameter name, or another modifier, follows a modifier word. */ startsTypeParameter(token) { if (this.typeParameterModifier(token)) return true; if (token.type === types_1.TokenType.IDENTIFIER) return token.value !== 'extends'; // `<берун мерос рақам>`: a parameter named `берун` return token.type !== types_1.TokenType.МЕРОС && this.isBuiltinIdentifierType(token.type); } /** * TypeScript's rules for type parameter modifiers: `собит` only on functions, * methods and classes, `дар`/`берун` only on classes, interfaces and type aliases. */ checkTypeParameterModifiers(typeParameters, owner) { for (const parameter of typeParameters ?? []) { const at = `at line ${parameter.line}, column ${parameter.column}`; if (parameter.const && (owner === 'interface' || owner === 'alias')) { this.errors.push(`'собит' modifier can only appear on a type parameter of a function, method or class ${at}`); } if ((parameter.in || parameter.out) && owner === 'function') { const word = parameter.in ? 'дар' : 'берун'; this.errors.push(`'${word}' modifier can only appear on a type parameter of a class, interface or type alias ${at}`); } } } /** `мерос А, Б<Т>` — the parent interfaces, or undefined without a clause. */ parseInterfaceExtendsClause() { if (!this.match(types_1.TokenType.МЕРОС)) { return undefined; } const parents = []; do { const parent = this.parseGenericOrIdentifierType(); if (!parent) { throw new Error(`Expected interface name after 'мерос' at line ${this.peek().line}, column ${this.peek().column}`); } parents.push(parent); } while (this.match(types_1.TokenType.COMMA)); return parents; } parseInterfaceProperties() { const properties = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { properties.push(this.propertySignature()); } return properties; } interfaceDeclaration() { const interfaceToken = this.previous(); const name = this.parseImportOrExportName('Expected interface name'); const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'interface'); const parents = this.parseInterfaceExtendsClause(); this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after interface name"); const properties = this.parseInterfaceProperties(); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after interface body"); return { type: 'InterfaceDeclaration', name: { type: 'Identifier', name: name.value, line: name.line, column: name.column, }, typeParameters, extends: parents, body: { type: 'InterfaceBody', properties, line: interfaceToken.line, column: interfaceToken.column, }, line: interfaceToken.line, column: interfaceToken.column, }; } /** * Index signature `[калид: сатр]: Т;`: the key parameter is kept as * `indexSignature` (as for a class's index signature); the key is the * placeholder `__computed__`. */ parseComputedPropertySignature(readonly) { const bracket = this.advance(); // consume '[' const name = this.createIdentifier(this.advance()); this.consume(types_1.TokenType.COLON, "Expected ':' in index signature"); const keyType = this.typeAnnotation(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property name"); this.consume(types_1.TokenType.COLON, "Expected ':' after computed property name"); const typeAnnotation = this.typeAnnotation(); this.consumeMemberSeparator("Expected ';' after property type"); return { type: 'PropertySignature', key: { type: 'Identifier', name: '__computed__', // Placeholder for computed property line: bracket.line, column: bracket.column, }, typeAnnotation, optional: false, readonly, indexSignature: { type: 'Parameter', name, typeAnnotation: keyType, line: name.line, column: name.column, }, line: bracket.line, column: bracket.column, }; } /** * Method signature `ном[?][<Т>](параметрҳо)[: Навъ];`, recorded as a member * whose type is the function type. A missing return type is `ҳар`, as in * TypeScript. */ parseMethodSignature(keyName, readonly, optional) { const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); const openParen = this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' in method signature"); const { params: parameters, thisType } = this.parseParametersWithThis("Expected ')' after method parameters"); const returnType = this.match(types_1.TokenType.COLON) ? this.parseReturnType() : { type: 'PrimitiveType', name: 'ҳар', line: openParen.line, column: openParen.column, }; this.consumeMemberSeparator("Expected ';' after method signature"); const functionType = { type: 'FunctionType', parameters, returnType, ...(thisType && { thisType: thisType.typeAnnotation }), line: keyName.line, column: keyName.column, }; return { type: 'PropertySignature', key: this.createSignatureKey(keyName), typeAnnotation: { type: 'TypeAnnotation', typeAnnotation: functionType, line: keyName.line, column: keyName.column, }, optional, readonly, method: true, ...(typeParameters && { typeParameters }), line: keyName.line, column: keyName.column, }; } /** * `[ифода]: Т;` / `[ифода](…): Т;`, a member with a computed name such as a * `беназир рамз` (unique symbol) constant. Its name is only known at run * time, so it is marked `computed` (the expression is `computedKey`) and * the type checker leaves it out. */ parseComputedNameSignature(readonly) { const open = this.advance(); // '[' // The name: the type checker leaves the member out, the TypeScript emitter keeps it const computedKey = this.assignment(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property name"); const keyName = { ...open, type: types_1.TokenType.IDENTIFIER, value: '__computed_name__' }; const optional = this.match(types_1.TokenType.QUESTION); const signature = this.check(types_1.TokenType.LEFT_PAREN) || this.check(types_1.TokenType.LESS_THAN) ? this.parseMethodSignature(keyName, readonly, optional) : this.finishPropertySignature(keyName, readonly, optional); return { ...signature, computed: true, computedKey }; } /** * A call signature `<Т>(х: Т): Т;` or construct signature `нав (х: рақам): К;` * of an interface or object type, after `нав`: a member named * `__call__` / `__new__` whose type is the function or constructor type. A * missing return type is `ҳар`, as in TypeScript. */ parseCallSignature(kind, start) { const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); const open = this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' in a call signature"); const { params: parameters, thisType } = this.parseParametersWithThis("Expected ')' after signature parameters"); const returnType = this.match(types_1.TokenType.COLON) ? this.parseReturnType() : { type: 'PrimitiveType', name: 'ҳар', line: open.line, column: open.column }; this.consumeMemberSeparator("Expected ';' after a signature"); const position = { line: start.line, column: start.column }; const signatureType = kind === 'call' ? { type: 'FunctionType', parameters, returnType, ...(thisType && { thisType: thisType.typeAnnotation }), ...position, } : { type: 'ConstructorType', parameters, returnType, ...position }; return { type: 'PropertySignature', // The placeholder name sits at the `(`: `нав` stays a keyword for the formatter key: { type: 'Identifier', name: kind === 'call' ? '__call__' : '__new__', line: open.line, column: open.column, }, typeAnnotation: { type: 'TypeAnnotation', typeAnnotation: signatureType, ...position }, optional: false, signature: kind, ...(typeParameters && { typeParameters }), ...position, }; } /** `get ном(): Т;` / `set ном(қ: Т);`: a property, read-only with a getter alone. */ parseAccessorSignature(accessor, keyName) { this.consume(types_1.TokenType.LEFT_PAREN, `Expected '(' after the name of a '${accessor}' accessor`); const params = this.parseParameterList("Expected ')' after accessor parameters"); const returnType = this.match(types_1.TokenType.COLON) ? this.typeAnnotation() : undefined; this.consumeMemberSeparator("Expected ';' after accessor signature"); const method = { type: 'FunctionExpression', params, returnType, line: keyName.line, column: keyName.column, }; this.checkAccessorParams(accessor, method, keyName); const typeAnnotation = accessor === 'get' ? returnType : (params[0]?.typeAnnotation ?? returnType); return { type: 'PropertySignature', key: this.createSignatureKey(keyName), typeAnnotation: typeAnnotation ?? { type: 'TypeAnnotation', typeAnnotation: { type: 'PrimitiveType', name: 'ҳар', line: keyName.line, column: keyName.column, }, line: keyName.line, column: keyName.column, }, optional: false, kind: accessor, line: keyName.line, column: keyName.column, }; } /** The name of an interface or object type member: any word, a string or a number. */ parsePropertyKeyName() { const token = this.peek(); if (token.type === types_1.TokenType.STRING || this.isIdentifierNameToken(token)) { return this.advance(); } if (token.type === types_1.TokenType.NUMBER) { this.checkBigIntName(token); return this.advance(); } throw new Error(`Expected property name at line ${token.line}, column ${token.column}`); } /** `"а-б": Т` and `1: Т` keep their literal names; any other name is an identifier. */ createSignatureKey(token) { if (token.type === types_1.TokenType.STRING) return this.createLiteral(token.value, token); if (token.type === types_1.TokenType.NUMBER) return this.createNumericLiteral(token); return this.createIdentifier(token); } /** TypeScript's TS1539: `1n` is no property name. */ checkBigIntName(token) { if (token.type === types_1.TokenType.NUMBER && token.value.endsWith('n')) { this.errors.push(`A bigint literal cannot be used as a property name at line ${token.line}, column ${token.column}`); } } /** * Modifiers that a member of an interface or object type cannot have * (TypeScript's TS1070, and TS1275 for `дастрасӣ`): reported, then skipped. */ skipTypeMemberModifiers() { for (;;) { const token = this.peek(); const isModifier = Parser.CLASS_ONLY_MODIFIERS.has(token.type) || (token.type === types_1.TokenType.IDENTIFIER && this.memberModifier(token) !== undefined); if (!isModifier || !this.modifierApplies()) return; const at = `at line ${token.line}, column ${token.column}`; this.errors.push(this.memberModifier(token) === 'accessor' ? `'${token.value}' modifier can only appear on a property declaration ${at}` : `'${token.value}' modifier cannot appear on a type member ${at}`); this.advance(); } } propertySignature() { this.skipTypeMemberModifiers(); // `танҳохонӣ ном: Т;` — a member may itself be named `танҳохонӣ` const readonly = this.check(types_1.TokenType.ТАНҲОХОНӢ) && this.modifierApplies() && !!this.advance(); // Call and construct signatures: `(х: рақам): сатр;`, `нав (х: рақам): К;` if (this.check(types_1.TokenType.LEFT_PAREN) || this.check(types_1.TokenType.LESS_THAN)) { return this.parseCallSignature('call', this.peek()); } const afterNew = this.peekNext()?.type; if (this.check(types_1.TokenType.НАВ) && (afterNew === types_1.TokenType.LEFT_PAREN || afterNew === types_1.TokenType.LESS_THAN)) { return this.parseCallSignature('construct', this.advance()); } // Index signatures `[калид: сатр]: Т;` if (this.isIndexSignatureStart()) { return this.parseComputedPropertySignature(readonly); } // Computed names `[калид]: Т;`, `[Symbol.iterator](): Т;` if (this.check(types_1.TokenType.LEFT_BRACKET)) { return this.parseComputedNameSignature(readonly); } // `get ном(): Т;`, `set ном(қ: Т);` const accessor = this.parseAccessorKind(); if (accessor) { return this.parseAccessorSignature(accessor, this.parsePropertyKeyName()); } const keyName = this.parsePropertyKeyName(); const optional = this.match(types_1.TokenType.QUESTION); // Method signature: `ном(…): Навъ`, `ном?(…)`, `ном<Т>(…)` if (this.check(types_1.TokenType.LEFT_PAREN) || this.check(types_1.TokenType.LESS_THAN)) { return this.parseMethodSignature(keyName, readonly, optional); } return this.finishPropertySignature(keyName, readonly, optional); } /** The `: Т;` of a property signature `ном: Т;`. */ finishPropertySignature(keyName, readonly, optional) { // Regular property signature: propName: type; this.consume(types_1.TokenType.COLON, "Expected ':' after property name"); const typeAnnotation = this.typeAnnotation(); this.consumeMemberSeparator("Expected ';' after property type"); return { type: 'PropertySignature', key: this.createSignatureKey(keyName), typeAnnotation, optional: optional || false, readonly, line: keyName.line, column: keyName.column, }; } /** * `мерос Асос<Т>`: the base class, as in TypeScript any left-hand side * expression (`мерос Н.Асос`, `мерос Омехта(Асос)`), and its type arguments. */ parseClassExtendsClause() { if (!this.match(types_1.TokenType.МЕРОС)) { return undefined; } if (this.check(types_1.TokenType.LEFT_BRACE)) { throw new Error(this.unexpectedTokenMessage("Expected superclass name after 'мерос'")); } const expression = this.applyCallChaining(this.primary()); // `мерос Асос<Т>` before a line break reads as an instantiation expression if (expression.type === 'InstantiationExpression' && !this.parenthesized.has(expression)) { const instantiation = expression; return { expression: instantiation.expression, typeArguments: instantiation.typeArguments }; } return { expression, typeArguments: this.parseNewTypeArguments() }; } parseClassImplementsClause() { if (!this.match(types_1.TokenType.ТАТБИҚ)) { return []; } const entries = []; do { const token = this.parseImportOrExportName('Expected interface name in implements clause'); entries.push({ token, typeArguments: this.parseNewTypeArguments() }); } while (this.match(types_1.TokenType.COMMA)); return entries; } /** The heritage fields of a class node, from its `мерос` / `татбиқ` clauses. */ heritageFields(superClass, implementsEntries) { const fields = { superClass: superClass?.expression, implements: implementsEntries.map(entry => this.createIdentifier(entry.token)), }; if (superClass?.typeArguments) fields.superTypeArguments = superClass.typeArguments; if (implementsEntries.some(entry => entry.typeArguments)) { fields.implementsTypeArguments = implementsEntries.map(entry => entry.typeArguments); } return fields; } consumeClassBody() { this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after class declaration"); // Class members are never in a generator body, even inside a generator const body = this.withGenerator(false, () => this.classBody()); if (this.check(types_1.TokenType.RIGHT_BRACE)) { this.advance(); } else { const token = this.peek(); this.errors.push(`Expected '}' after class body at line ${token.line}, column ${token.column}`); } return body; } classDeclaration() { const classToken = this.previous(); const nameToken = this.parseImportOrExportName('Expected class name'); const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'class'); const superClass = this.parseClassExtendsClause(); const implementsEntries = this.parseClassImplementsClause(); const body = this.consumeClassBody(); return { type: 'ClassDeclaration', name: { type: 'Identifier', name: nameToken.value, line: nameToken.line, column: nameToken.column, }, ...(typeParameters && { typeParameters }), ...this.heritageFields(superClass, implementsEntries), body, ...(this.ambient && { declare: true }), line: classToken.line, column: classToken.column, }; } startsClassExpression() { return this.check(types_1.TokenType.СИНФ) || this.check(types_1.TokenType.AT); } /** `синф { … }` or, decorated, `@д синф { … }` in expression position. */ classExpression() { const decorators = this.parseDecorators(); const classToken = this.consume(types_1.TokenType.СИНФ, "Expected 'синф' after decorators"); const classExpression = this.parseClassExpression(classToken); if (decorators.length > 0) classExpression.decorators = decorators; return classExpression; } /** * `синф [Ном] [мерос Асос] [татбиқ И] { … }` in expression position; the * name is optional (`мерос`/`татбиқ` right after `синф` start the heritage). */ parseClassExpression(classToken) { const nameToken = this.check(types_1.TokenType.LEFT_BRACE) || this.check(types_1.TokenType.МЕРОС) || this.check(types_1.TokenType.ТАТБИҚ) || this.check(types_1.TokenType.LESS_THAN) ? undefined : this.parseImportOrExportName("Expected class name or '{'"); const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'class'); const superClass = this.parseClassExtendsClause(); const implementsEntries = this.parseClassImplementsClause(); const body = this.consumeClassBody(); const classExpression = { type: 'ClassExpression', ...(typeParameters && { typeParameters }), ...this.heritageFields(superClass, implementsEntries), body, line: classToken.line, column: classToken.column, }; if (nameToken) classExpression.name = this.createIdentifier(nameToken); return classExpression; } classBody() { const members = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const memberStart = this.current; try { // `статикӣ { … }`; a member named `статикӣ` is followed by '(', ':', '=', … const member = this.checkSequence(types_1.TokenType.СТАТИКӢ, types_1.TokenType.LEFT_BRACE) ? this.staticBlock() : this.classMember(); if (member) { members.push(member); } } catch (error) { if (this.isNestingError(error)) throw error; this.errors.push(error.message); if (this.recoverFromClassMemberError(memberStart)) { break; } } } if (!this.ambient) this.checkMethodOverloads(members); return { type: 'ClassBody', body: members, line: this.peek().line, column: this.peek().column, }; } recoverFromClassMemberError(memberStart) { // Never stop where the failed member started, or the loop would not advance if (this.current === memberStart && !this.isAtEnd()) { this.advance(); } // Skip the rest of the failed member: up to its ';' or its '{ … }' body while (this.shouldContinueErrorRecovery()) { if (this.match(types_1.TokenType.LEFT_BRACE)) { this.skipBalancedBraces(); break; } if (this.match(types_1.TokenType.SEMICOLON)) break; this.advance(); } return this.isAtClassOrNamespaceKeyword(); } /** Skips tokens up to and including the '}' matching an already consumed '{'. */ skipBalancedBraces() { let depth = 1; while (depth > 0 && !this.isAtEnd()) { if (this.check(types_1.TokenType.LEFT_BRACE)) depth++; else if (this.check(types_1.TokenType.RIGHT_BRACE)) depth--; this.advance(); } } shouldContinueErrorRecovery() { return (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.check(types_1.TokenType.ҶАМЪИЯТӢ) && !this.check(types_1.TokenType.ХОСУСӢ) && !this.check(types_1.TokenType.МУҲОФИЗАТШУДА) && !this.check(types_1.TokenType.КОНСТРУКТОР) && !this.check(types_1.TokenType.СИНФ) && !this.check(types_1.TokenType.МАВҲУМ) && !this.check(types_1.TokenType.НОМФАЗО) && !this.isAtEnd()); } isAtClassOrNamespaceKeyword() { return (this.check(types_1.TokenType.СИНФ) || this.check(types_1.TokenType.МАВҲУМ) || this.check(types_1.TokenType.НОМФАЗО)); } parseAccessibility() { const isAccessibility = this.check(types_1.TokenType.ҶАМЪИЯТӢ) || this.check(types_1.TokenType.ХОСУСӢ) || this.check(types_1.TokenType.МУҲОФИЗАТШУДА); if (!isAccessibility || !this.modifierApplies()) return undefined; const accessToken = this.advance(); if (accessToken.type === types_1.TokenType.ҶАМЪИЯТӢ) return 'public'; if (accessToken.type === types_1.TokenType.ХОСУСӢ) return 'private'; return 'protected'; } parseModifiers() { const isStatic = this.check(types_1.TokenType.СТАТИКӢ) && this.modifierApplies() && !!this.advance(); const isAbstract = this.check(types_1.TokenType.МАВҲУМ) && this.modifierApplies() && !!this.advance(); return { isStatic, isAbstract }; } /** * Whether the modifier word at `offset` (`статикӣ`, `хосусӣ`, `ҳамзамон`, * `бознавис`, …) is a modifier, by TypeScript's rule: the rest of a member * follows it — a name, string, number, `#ном`, `[`, `{`, `*` or `...` — on * its line (after `статикӣ` also on the next one). Otherwise the word is the * member's name: `статикӣ() {}`, `хосусӣ = 1`, `ҳамзамон: рақам`. */ modifierApplies() { // At a modifier word, which is no EOF: a token follows const token = this.peek(); const next = this.tokens[this.current + 1]; if (next.line !== token.line && token.type !== types_1.TokenType.СТАТИКӢ) return false; return Parser.MODIFIER_FOLLOWERS.has(next.type) || this.isIdentifierNameToken(next); } /** * A class member's name: any word, keywords included (`агар() {}`, * `бозгашт = 1`, `нав()`), or `#ном`. A `функсия` before a name is skipped. */ parseMemberName() { const next = this.peekNext(); if (this.check(types_1.TokenType.ФУНКСИЯ) && next && this.isIdentifierNameToken(next)) { this.advance(); } if (this.check(types_1.TokenType.PRIVATE_NAME) || this.isIdentifierNameToken(this.peek())) { return this.advance(); } throw new Error(`Expected class member at line ${this.peek().line}, column ${this.peek().column}`); } /** * A class member's name: `ном`, `#ном`, a string or number literal * (`"ном"`, `1`) or a computed name `[ифода]` (`[Symbol.iterator]`). * `token` is where the name starts, for messages. */ parseClassMemberKey() { if (this.check(types_1.TokenType.LEFT_BRACKET)) { const open = this.advance(); const key = this.assignment(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed member name"); return { key, token: open, computed: true }; } if (this.check(types_1.TokenType.STRING) || this.check(types_1.TokenType.NUMBER)) { this.checkBigIntName(this.peek()); const token = this.advance(); const key = token.type === types_1.TokenType.STRING ? this.createLiteral(token.value, token) : this.createNumericLiteral(token); return { key, token, computed: false }; } const token = this.parseMemberName(); return { key: this.createMemberKey(token), token, computed: false }; } /** * `get`/`set` before a member name (`ном`, `#ном`, `"ном"`, `[калид]`) and * its '(' make an accessor; anywhere else they are ordinary names. */ parseAccessorKind() { const token = this.peek(); const name = this.peekNext(); if (token.type !== types_1.TokenType.IDENTIFIER || !['get', 'set'].includes(token.value) || !name) { return undefined; } let nameEnd = -1; if (name.type === types_1.TokenType.LEFT_BRACKET) { nameEnd = this.findMatchingBracket(this.current + 1); } else if (Parser.ACCESSOR_NAME_TOKENS.has(name.type) || this.isIdentifierNameToken(name)) { nameEnd = this.current + 1; } if (nameEnd === -1 || this.tokens[nameEnd + 1]?.type !== types_1.TokenType.LEFT_PAREN) return undefined; this.advance(); return token.value; } /** Early errors of private names: no accessibility modifier, never `#constructor`. */ checkPrivateMemberName(nameToken, accessibility) { if (nameToken.type !== types_1.TokenType.PRIVATE_NAME) return; const at = `at line ${nameToken.line}, column ${nameToken.column}`; if (nameToken.value === '#constructor') { this.errors.push(`Classes may not have a private field named '#constructor' ${at}`); } if (accessibility) { this.errors.push(`An accessibility modifier cannot be used with a private identifier '${nameToken.value}' ${at}`); } } /** Kind and type parameters of a parsed method. */ finishClassMethod(method, accessor, typeParameters) { if (typeParameters) method.value.typeParameters = typeParameters; if (accessor) { method.kind = accessor; this.checkAccessorParams(accessor, method.value, method); } return method; } /** * A getter takes no parameter and a setter exactly one, as JavaScript * requires; a setter has no return type, as TypeScript requires. */ checkAccessorParams(accessor, method, at) { const params = method.params; const position = `at line ${at.line}, column ${at.column}`; if (method.thisType) { this.errors.push(`'get' and 'set' accessors cannot declare 'ин' parameters ${position}`); } if (accessor === 'get' && params.length > 0) { this.errors.push(`Getter must not have any formal parameters ${position}`); } else if (accessor === 'set' && (params.length !== 1 || params[0].rest)) { this.errors.push(`Setter must have exactly one formal parameter ${position}`); } else if (accessor === 'set' && method.returnType) { this.errors.push(`A 'set' accessor cannot have a return type annotation ${position}`); } } /** `танҳохонӣ ном: Т` — unless `танҳохонӣ` is itself the member name. */ parseReadonlyModifier() { if (!this.check(types_1.TokenType.ТАНҲОХОНӢ) || !this.modifierApplies()) return false; this.advance(); return true; } /** * Contextual member modifiers after the accessibility and `статикӣ`: * `бознавис` (override), `эълон` (declare), `дастрасӣ` (accessor) and a * later `мавҳум`, in any order. Each is a modifier only when the rest of a * member follows on its line; `бознавис() {}` is a method named `бознавис`. */ parseMemberModifiers() { const modifiers = {}; // eslint-disable-next-line no-constant-condition while (true) { const token = this.peek(); const modifier = this.memberModifier(token); if (!modifier || !this.modifierApplies()) return modifiers; const at = `at line ${token.line}, column ${token.column}`; if (modifiers[modifier]) { this.errors.push(`'${token.value}' modifier already seen ${at}`); } else if (modifier === 'static') { // `бознавис статикӣ м()`: as in TypeScript, `статикӣ` comes first this.errors.push(`'${token.value}' modifier must precede the modifiers before it ${at}`); } modifiers[modifier] = true; this.advance(); } } memberModifier(token) { if (token.type === types_1.TokenType.МАВҲУМ) return 'abstract'; if (token.type === types_1.TokenType.СТАТИКӢ) return 'static'; if (token.type !== types_1.TokenType.IDENTIFIER) return undefined; if (Parser.OVERRIDE_KEYWORDS.has(token.value)) return 'override'; if (Parser.DECLARE_KEYWORDS.has(token.value)) return 'declare'; if (Parser.ACCESSOR_KEYWORDS.has(token.value)) return 'accessor'; return undefined; } /** `[калид: сатр]: Т` (an index signature) starts here. */ isIndexSignatureStart() { const name = this.tokens[this.current + 1]; return (this.check(types_1.TokenType.LEFT_BRACKET) && name !== undefined && this.isPlainIdentifierToken(name) && this.tokens[this.current + 2]?.type === types_1.TokenType.COLON); } /** Decorators and modifiers before a class member. */ parseMemberHead() { const decorators = this.parseDecorators(); const accessibility = this.parseAccessibility(); const { isStatic, isAbstract } = this.parseModifiers(); const modifiers = this.parseMemberModifiers(); return { decorators, accessibility, isStatic: isStatic || Boolean(modifiers.static), isAbstract: isAbstract || Boolean(modifiers.abstract), modifiers, }; } classMember() { const head = this.parseMemberHead(); // Constructor if (this.match(types_1.TokenType.КОНСТРУКТОР)) { this.rejectDecorators(head.decorators); return this.constructorMethod(head.accessibility, head.isStatic); } const isAsync = this.matchAsyncModifier(); // `*ном() {…}`: a generator method const isGenerator = this.match(types_1.TokenType.MULTIPLY); const isReadonly = !isAsync && this.parseReadonlyModifier(); // `[калид: сатр]: рақам;` if (!isAsync && !isGenerator && this.isIndexSignatureStart()) { this.rejectDecorators(head.decorators); return this.classIndexSignature(head.isStatic, isReadonly); } // `get ном() {…}`, `set ном(қимат) {…}` const accessor = isAsync ? undefined : this.parseAccessorKind(); const name = this.parseClassMemberKey(); this.checkPrivateMemberName(name.token, head.accessibility); const optional = this.matchOptionalMethodMarker(); // A generic method: `метод<Т>(х: Т)` const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'function'); if (accessor || this.check(types_1.TokenType.LEFT_PAREN)) { return this.methodMember(head, name, { isAsync, isGenerator, isReadonly, accessor, optional, typeParameters, }); } if (isAsync || isGenerator) { throw new Error(`Expected method after '${isGenerator ? '*' : 'ҳамзамон'}' at line ${name.token.line}, column ${name.token.column}`); } return this.propertyMember(head, name, isReadonly); } /** `ҳамзамон ном() {…}` — unless `ҳамзамон` is itself the member name. */ matchAsyncModifier() { if (!this.isAsyncWord() || !this.modifierApplies()) return false; this.advance(); return true; } /** `м?() {…}`, `м?(): Т;`: the `?` of an optional method. */ matchOptionalMethodMarker() { const next = this.peekNext()?.type; return (this.check(types_1.TokenType.QUESTION) && (next === types_1.TokenType.LEFT_PAREN || next === types_1.TokenType.LESS_THAN) && this.match(types_1.TokenType.QUESTION)); } /** A method, accessor or method signature, after its name. */ methodMember(head, name, flags) { const at = `at line ${name.token.line}, column ${name.token.column}`; if (flags.isReadonly) { this.errors.push(`'танҳохонӣ' can only be used on a property ${at}`); } if (head.modifiers.accessor || head.modifiers.declare) { const word = head.modifiers.accessor ? 'дастрасӣ' : 'эълон'; this.errors.push(`'${word}' modifier can only appear on a property declaration ${at}`); } // `classMethod` parses a generator body for `*ном() {…}` const method = this.withGenerator(flags.isGenerator, () => this.classMethod(name, head, flags.isAsync)); if (flags.optional) method.optional = true; if (head.modifiers.override) method.override = true; this.finishClassMethod(method, flags.accessor, flags.typeParameters); this.attachMemberDecorators(method, head.decorators); return method; } /** A field, after its name: `ном: Т = …;` with its modifiers. */ propertyMember(head, name, isReadonly) { const property = this.classProperty(name, head.accessibility, head.isStatic); const flags = { readonly: isReadonly, override: head.modifiers.override, declare: head.modifiers.declare, accessor: head.modifiers.accessor, abstract: head.isAbstract, }; for (const [flag, value] of Object.entries(flags)) { if (value) property[flag] = true; } this.checkPropertyModifiers(property, name.token); this.attachMemberDecorators(property, head.decorators); return property; } /** Decorators before a member that may not have them (a constructor, an index signature). */ rejectDecorators(decorators) { if (decorators.length > 0) this.reportInvalidDecorators(decorators); } /** TypeScript's rules for `эълон`, `мавҳум` and `дастрасӣ` fields. */ checkPropertyModifiers(property, at) { const position = `at line ${at.line}, column ${at.column}`; if ((property.declare || property.abstract || this.ambient) && property.value) { const reason = property.abstract ? `Property '${at.value}' cannot have an initializer because it is marked abstract` : 'Initializers are not allowed in ambient contexts'; this.errors.push(`${reason} ${position}`); } if (property.accessor && property.readonly) { this.errors.push(`'дастрасӣ' modifier cannot be used with 'танҳохонӣ' modifier ${position}`); } if (property.accessor && property.declare) { this.errors.push(`'дастрасӣ' modifier cannot be used with 'эълон' modifier ${position}`); } } /** * Decorators of a class member: methods with bodies, accessors and fields * (TypeScript rejects them elsewhere). */ attachMemberDecorators(member, decorators) { if (decorators.length === 0) return; if (member.type === 'MethodDefinition' && member.signature) { const at = decorators[0]; this.errors.push(`A decorator can only decorate a method implementation, not an overload at line ${at.line}, column ${at.column}`); return; } const ambientField = member.type === 'PropertyDefinition' && member.declare; if (member.abstract || ambientField || this.ambient) { this.reportInvalidDecorators(decorators); return; } member.decorators = decorators; } /** TypeScript's "Decorators are not valid here" (TS1206). */ reportInvalidDecorators(decorators) { const at = decorators[0]; this.errors.push(`Decorators are not valid here at line ${at.line}, column ${at.column}`); } /** Class static initialization block: `статикӣ { … }`. */ staticBlock() { const staticToken = this.advance(); this.advance(); // consume '{' const block = this.blockStatement(); return { type: 'StaticBlock', body: block.body, line: staticToken.line, column: staticToken.column, }; } constructorMethod(accessibility, isStatic) { const constructorToken = this.previous(); const access = accessibility === 'public' || accessibility === 'private' || accessibility === 'protected' ? accessibility : undefined; this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after constructor"); const params = this.parseParameterList("Expected ')' after constructor parameters", true); // `конструктор(х: рақам);`: an overload signature, or a declared constructor let signature = false; let body; if (!this.check(types_1.TokenType.LEFT_BRACE) && this.isSignatureEnd()) { this.consumeSemicolon("Expected '{' after constructor parameters"); signature = true; body = { type: 'BlockStatement', body: [], line: constructorToken.line, column: constructorToken.column, }; const property = params.find(param => param.accessibility || param.readonly || param.override); if (property) { this.errors.push(`A parameter property is only allowed in a constructor implementation at line ${property.line}, column ${property.column}`); } } else { this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after constructor parameters"); if (this.ambient) this.reportImplementationInAmbientContext(constructorToken); body = this.blockStatement(); } return { type: 'MethodDefinition', key: { type: 'Identifier', name: 'constructor', line: constructorToken.line, column: constructorToken.column, }, value: { type: 'FunctionExpression', params: params, body: body, line: constructorToken.line, column: constructorToken.column, }, kind: 'constructor', static: isStatic || false, accessibility: access, ...(signature && { signature }), line: constructorToken.line, column: constructorToken.column, }; } classMethod(name, head, isAsync) { // A generator method (`*ном() {…}`) is parsed in a generator context const isGenerator = this.inGenerator; const nameToken = name.token; this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after method name"); const { params, thisType } = this.withGenerator(false, () => this.parseParametersWithThis("Expected ')' after method parameters", true)); let returnType; if (this.match(types_1.TokenType.COLON)) { returnType = this.returnTypeAnnotation(); } const { body, signature } = this.parseMethodBody(nameToken, head.isAbstract); return { type: 'MethodDefinition', key: name.key, value: { type: 'FunctionExpression', params: params, body: body, returnType, async: isAsync || undefined, ...(isGenerator && { generator: true }), ...(thisType && { thisType }), line: nameToken.line, column: nameToken.column, }, kind: 'method', static: head.isStatic, abstract: head.isAbstract, accessibility: head.accessibility, ...(name.computed && { computed: true }), ...(signature && { signature }), line: nameToken.line, column: nameToken.column, }; } /** * A method's body; none for an abstract method, an overload signature * (`м(х: рақам): рақам;`) or a member of an `эълон синф` (`signature`). */ parseMethodBody(nameToken, isAbstract) { const emptyBody = { type: 'BlockStatement', body: [], line: nameToken.line, column: nameToken.column, }; if (isAbstract) { // Abstract methods end with semicolon, no body this.consumeSemicolon("Expected ';' after abstract method signature"); return { body: emptyBody, signature: false }; } if (!this.check(types_1.TokenType.LEFT_BRACE) && this.isSignatureEnd()) { this.consumeSemicolon("Expected '{' after method signature"); return { body: emptyBody, signature: true }; } // Regular methods have a body this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after method signature"); if (this.ambient) this.reportImplementationInAmbientContext(nameToken); return { body: this.blockStatement(), signature: false }; } classProperty(name, accessibility, isStatic) { // Optional property marker (`ном?: сатр`): the property may be `беқимат` const optional = this.match(types_1.TokenType.QUESTION); // Definite assignment assertion: `ном!: сатр` const definite = !optional && this.checkNonNullAssertion() ? this.advance() : undefined; // Optional type annotation let typeAnnotation; if (this.match(types_1.TokenType.COLON)) { typeAnnotation = this.typeAnnotation(); } // Optional initializer let value = undefined; if (this.match(types_1.TokenType.ASSIGN)) { value = this.assignment(); } if (definite) { this.checkDefiniteAssignment(definite, value !== undefined, typeAnnotation !== undefined, !isStatic); } // As in JavaScript, a field ends with ';', '}' or a line break: `а = 1 б = 2` is an error this.consumeSemicolon("Expected ';' after a class field"); return { type: 'PropertyDefinition', key: name.key, value: value, typeAnnotation: typeAnnotation, ...(optional && { optional }), ...(definite && { definite: true }), static: isStatic, accessibility, ...(name.computed && { computed: true }), line: name.token.line, column: name.token.column, }; } /** * `[калид: сатр]: рақам;` (also `статикӣ`, `танҳохонӣ`): types only, kept as * a property definition with an `indexSignature` and erased in the output. */ classIndexSignature(isStatic, isReadonly) { const open = this.advance(); // '[' const name = this.createIdentifier(this.advance()); this.consume(types_1.TokenType.COLON, "Expected ':' in index signature"); const keyType = this.typeAnnotation(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after index signature parameter"); this.consume(types_1.TokenType.COLON, 'An index signature must have a type annotation'); const typeAnnotation = this.typeAnnotation(); this.consumeSemicolon("Expected ';' after index signature"); return { type: 'PropertyDefinition', key: { type: 'Identifier', name: '__computed__', line: open.line, column: open.column }, typeAnnotation, static: isStatic, ...(isReadonly && { readonly: true }), indexSignature: { type: 'Parameter', name, typeAnnotation: keyType, line: name.line, column: name.column, }, line: open.line, column: open.column, }; } /** Name of a member for matching overloads; a computed name by its expression (`[к]`). */ memberKeyText(member) { if (member.computed) { return `[${JSON.stringify(member.key, (key, value) => key === 'line' || key === 'column' ? undefined : value)}]`; } const key = member.key; if (key.type === 'PrivateIdentifier') return `#${key.name}`; return key.type === 'Literal' ? String(key.value) : key.name; } /** * Each overload signature of a method or constructor (`м(х: рақам): рақам;`) * must be followed by another one or the implementation, as in TypeScript. */ checkMethodOverloads(members) { members.forEach((member, index) => { if (member.type !== 'MethodDefinition' || !member.signature || member.optional) return; const next = members[index + 1]; const name = this.memberKeyText(member); const continues = next?.type === 'MethodDefinition' && next.static === member.static && this.memberKeyText(next) === name; if (continues) return; const message = member.kind === 'constructor' ? 'Constructor implementation is missing' : 'Function implementation is missing or not immediately following the declaration'; this.errors.push(`${message} at line ${member.line}, column ${member.column}`); }); } typeAlias() { const typeToken = this.previous(); const name = this.parseImportOrExportName('Expected type alias name'); const typeParameters = this.parseTypeParameters(); this.checkTypeParameterModifiers(typeParameters, 'alias'); this.consume(types_1.TokenType.ASSIGN, "Expected '=' after type alias name"); const typeAnnotation = this.typeAnnotation(); this.consumeSemicolon("Expected ';' after type alias"); return { type: 'TypeAlias', name: { type: 'Identifier', name: name.value, line: name.line, column: name.column, }, typeParameters, typeAnnotation, line: typeToken.line, column: typeToken.column, }; } namespaceDeclaration() { const namespaceToken = this.previous(); const name = this.consume(types_1.TokenType.IDENTIFIER, 'Expected namespace name'); // `номфазо А.Б { … }` is `номфазо А { содир номфазо Б { … } }` if (this.match(types_1.TokenType.DOT)) { const inner = this.namespaceDeclaration(); inner.exported = true; return { type: 'NamespaceDeclaration', name: this.createIdentifier(name), body: { type: 'NamespaceBody', statements: [inner], line: namespaceToken.line, column: namespaceToken.column, }, ...(this.ambient && { declare: true }), line: namespaceToken.line, column: namespaceToken.column, }; } this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after namespace name"); const statements = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const isExported = this.match(types_1.TokenType.СОДИР); const stmt = this.parseNamespaceMember(isExported); if (stmt) { statements.push(stmt); } } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after namespace body"); if (!this.ambient) this.checkOverloads(statements); return { type: 'NamespaceDeclaration', name: { type: 'Identifier', name: name.value, line: name.line, column: name.column, }, body: { type: 'NamespaceBody', statements, line: namespaceToken.line, column: namespaceToken.column, }, ...(this.ambient && { declare: true }), line: namespaceToken.line, column: namespaceToken.column, }; } parseNamespaceMember(isExported) { // `содир эълон функсия ф(): Т;` if (this.isAmbientStart()) return this.markExported(this.ambientDeclaration(), isExported); if (this.match(types_1.TokenType.НОМФАЗО)) { const nestedNamespace = this.namespaceDeclaration(); if (isExported) { nestedNamespace.exported = true; } return nestedNamespace; } if (this.isEnumStart(0) || (this.check(types_1.TokenType.СОБИТ) && this.isEnumStart(1))) { const enumDecl = this.contextualStatement(); if (isExported) enumDecl.exported = true; return enumDecl; } const declaration = this.namespaceModifiedDeclaration(); if (declaration) return this.markExported(declaration, isExported); const declarationParsers = [ [types_1.TokenType.ИНТЕРФЕЙС, () => this.interfaceDeclaration()], [types_1.TokenType.НАВЪ, () => this.typeAlias()], [types_1.TokenType.СИНФ, () => this.classDeclaration()], [types_1.TokenType.ФУНКСИЯ, () => this.functionDeclaration()], [[types_1.TokenType.ТАҒЙИРЁБАНДА, types_1.TokenType.СОБИТ], () => this.variableDeclaration()], ]; for (const [tokenType, parser] of declarationParsers) { if (Array.isArray(tokenType) ? this.match(...tokenType) : this.match(tokenType)) { const stmt = parser(); if (isExported && stmt) { stmt.exported = true; } return stmt; } } if (isExported) { const token = this.peek(); throw new Error(`Expected a declaration after 'содир' at line ${token.line}, column ${token.column}`); } // Any other statement runs inside the namespace's function body return this.statement(); } /** * Namespace members that start with a modifier or `ворид`: `ҳамзамон функсия`, * `мавҳум синф` and the alias `ворид х = Н.а;` (also exported: * `содир ворид х = Н.а;`). */ namespaceModifiedDeclaration() { if (this.isAsyncFunctionStart()) { this.advance(); // 'ҳамзамон' / 'async' this.advance(); // 'функсия' const func = this.functionDeclaration(); func.async = true; return func; } if (this.checkSequence(types_1.TokenType.МАВҲУМ, types_1.TokenType.СИНФ)) { this.advance(); this.advance(); const classDecl = this.classDeclaration(); classDecl.abstract = true; return classDecl; } const next = this.peekNext(); if (this.check(types_1.TokenType.ВОРИД) && next && this.isPlainIdentifierToken(next)) { return this.importDeclaration(this.advance()); } return null; } markExported(statement, isExported) { if (isExported && statement) statement.exported = true; return statement; } parseSwitchCaseConsequent() { const consequent = []; while (!this.check(types_1.TokenType.ҲОЛАТ) && !this.check(types_1.TokenType.ПЕШФАРЗ) && !this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { const stmt = this.statement(); if (stmt) consequent.push(stmt); } return consequent; } parseRegularCase() { const test = this.expression(); this.consume(types_1.TokenType.COLON, "Expected ':' after case value"); const consequent = this.parseSwitchCaseConsequent(); return { type: 'SwitchCase', test, consequent, line: test.line, column: test.column, }; } parseDefaultCase() { this.consume(types_1.TokenType.COLON, "Expected ':' after default keyword"); const startToken = this.previous(); const consequent = this.parseSwitchCaseConsequent(); return { type: 'SwitchCase', test: undefined, consequent, line: startToken.line, column: startToken.column, }; } parseSwitchCases() { const cases = []; let foundDefault = false; // Tokens skipped up to the next `ҳолат`/`пешфарз` are one error, not one each let skipping = false; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { if (this.match(types_1.TokenType.ҲОЛАТ)) { skipping = false; cases.push(this.parseRegularCase()); continue; } if (this.match(types_1.TokenType.ПЕШФАРЗ)) { skipping = false; if (foundDefault) { const token = this.previous(); this.errors.push(`Multiple default cases in switch at line ${token.line}, column ${token.column}`); } foundDefault = true; cases.push(this.parseDefaultCase()); continue; } const token = this.advance(); if (!skipping) { this.errors.push(`Unexpected token '${token.value}' in switch at line ${token.line}, column ${token.column}`); } skipping = true; } return cases; } switchStatement() { const switchToken = this.previous(); this.consume(types_1.TokenType.LEFT_PAREN, "Expected '(' after 'интихоб'"); const discriminant = this.expression(); this.consume(types_1.TokenType.RIGHT_PAREN, "Expected ')' after switch expression"); this.consume(types_1.TokenType.LEFT_BRACE, "Expected '{' after switch expression"); const cases = this.parseSwitchCases(); this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' after switch cases"); return { type: 'SwitchStatement', discriminant, cases, line: switchToken.line, column: switchToken.column, }; } /** * Error recovery: skip to the end of the failed statement so one bad token * yields one error. Braces opened by the statement are skipped as a unit, * and a '}' that closes an enclosing block is left for that block. */ synchronize(startIndex) { let depth = this.braceDepthSince(startIndex); if (this.current === startIndex && !this.isAtEnd()) { // Guarantee progress: the statement could not even start (a `{` would have // started a block) this.advance(); } while (!this.isAtEnd()) { if (depth === 0 && this.isAtStatementBoundary()) return; if (this.check(types_1.TokenType.LEFT_BRACE)) { depth++; } else if (this.check(types_1.TokenType.RIGHT_BRACE)) { depth--; this.advance(); if (depth === 0) { // The braces may have belonged to an expression: `тағ о = { … };` this.match(types_1.TokenType.SEMICOLON); return; } continue; } this.advance(); } } /** Number of braces opened (and not yet closed) since `startIndex`. */ braceDepthSince(startIndex) { let depth = 0; for (let i = startIndex; i < this.current; i++) { if (this.tokens[i].type === types_1.TokenType.LEFT_BRACE) depth++; else if (this.tokens[i].type === types_1.TokenType.RIGHT_BRACE && depth > 0) depth--; } return depth; } isAtStatementBoundary() { return (this.previous().type === types_1.TokenType.SEMICOLON || this.check(types_1.TokenType.RIGHT_BRACE) || Parser.STATEMENT_KEYWORDS.has(this.peek().type)); } parsePattern() { if (this.match(types_1.TokenType.LEFT_BRACKET)) { return this.parseArrayPattern(); } if (this.match(types_1.TokenType.LEFT_BRACE)) { return this.parseObjectPattern(); } return this.parseIdentifierPattern(); } parseArrayPattern() { const leftBracket = this.previous(); const elements = []; while (!this.check(types_1.TokenType.RIGHT_BRACKET) && !this.isAtEnd()) { if (this.match(types_1.TokenType.COMMA)) { elements.push(null); continue; } if (this.match(types_1.TokenType.SPREAD)) { const spreadElem = this.parseSpreadElement(); elements.push(spreadElem); } else { elements.push(this.parsePatternWithDefault()); } if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' in array pattern"); return { type: 'ArrayPattern', elements, line: leftBracket.line, column: leftBracket.column, }; } parseObjectPattern() { const leftBrace = this.previous(); const properties = []; while (!this.check(types_1.TokenType.RIGHT_BRACE) && !this.isAtEnd()) { if (this.match(types_1.TokenType.SPREAD)) { properties.push(this.parseSpreadElement()); } else { properties.push(this.parsePropertyPattern()); } if (!this.match(types_1.TokenType.COMMA)) break; } this.consume(types_1.TokenType.RIGHT_BRACE, "Expected '}' in object pattern"); return { type: 'ObjectPattern', properties, line: leftBrace.line, column: leftBrace.column, }; } /** `ном`, `ном = 1`, `калид: ном`, `калид: { … } = {}` */ parsePropertyPattern() { const keyToken = this.peek(); let key; let computed = false; if (this.match(types_1.TokenType.STRING)) { key = this.createLiteral(keyToken.value, keyToken); } else if (this.match(types_1.TokenType.NUMBER)) { key = this.createNumericLiteral(keyToken); } else if (this.match(types_1.TokenType.LEFT_BRACKET)) { // `{ [калид]: қимат }` key = this.assignment(); this.consume(types_1.TokenType.RIGHT_BRACKET, "Expected ']' after computed property name"); computed = true; } else if (this.isIdentifierNameToken(keyToken)) { key = this.createIdentifier(this.advance()); } else { throw new Error(this.unexpectedTokenMessage('Expected identifier in object pattern')); } let value; if (this.match(types_1.TokenType.COLON)) { value = this.parsePatternWithDefault(); } else { // Shorthand `{ ном }` binds a variable named like the key if (key.type !== 'Identifier' || !this.isPlainIdentifierToken(keyToken)) { throw new Error(this.unexpectedTokenMessage("Expected ':' after property key in pattern")); } value = this.withDefault(this.createIdentifier(keyToken)); } return { type: 'PropertyPattern', key, value, computed, line: keyToken.line, column: keyToken.column, }; } parsePatternWithDefault() { return this.withDefault(this.parsePattern()); } /** Wraps `target` in an AssignmentPattern when a `= default` follows. */ withDefault(target) { if (!this.match(types_1.TokenType.ASSIGN)) { return target; } return { type: 'AssignmentPattern', left: target, right: this.assignment(), line: target.line, column: target.column, }; } parseIdentifierPattern() { // Allow certain keyword tokens to be treated as identifiers in binding patterns if (this.check(types_1.TokenType.IDENTIFIER)) { const identTok = this.advance(); return { type: 'Identifier', name: identTok.value, line: identTok.line, column: identTok.column, }; } if (this.matchBuiltinIdentifier()) { const token = this.previous(); return { type: 'Identifier', name: token.value, line: token.line, column: token.column, }; } throw new Error(this.unexpectedTokenMessage('Expected identifier')); } parseSpreadElement() { const spreadToken = this.previous(); // SPREAD token consumed by caller const argument = this.parsePattern(); return { type: 'SpreadElement', argument, line: spreadToken.line, column: spreadToken.column, }; } breakStatement() { const token = this.previous(); const label = this.parseJumpLabel(); this.consumeSemicolon("Expected ';' after 'шикастан'"); return { type: 'BreakStatement', ...(label && { label }), line: token.line, column: token.column, }; } continueStatement() { const token = this.previous(); const label = this.parseJumpLabel(); this.consumeSemicolon("Expected ';' after 'давом'"); return { type: 'ContinueStatement', ...(label && { label }), line: token.line, column: token.column, }; } /** The label of `шикастан берун;`; as in JavaScript it must be on the same line. */ parseJumpLabel() { if (this.isPlainIdentifierToken(this.peek()) && !this.hasLineBreakBefore()) { return this.createIdentifier(this.advance()); } return undefined; } } exports.Parser = Parser; /** * English keywords the parser reads as their Tajik ones: those the lexer * knows (`return`, `else`, `new`, …), the literals and `this`/`super`, and * TypeScript's member modifiers and type words. All but `readonly`, * `abstract`, `keyof` and `unique` are reserved words in JavaScript; those * four become words that are still names * where no modifier or type operator fits. Any of them names a member * (`о.return`, `{ new: 1 }`). `async` and `of` are keywords only in their * places (see `isAsyncWord`, `isOfWord`); `typeof`, `void`, `delete`, * `instanceof`, `do`, `yield`, `as`, `satisfies`, `is`, `asserts`, * `infer`, `declare`, `override`, `accessor`, `using`, `enum`, `type`, * `const`, `out`, `module` and `global` are read by their spelling. */ Parser.ENGLISH_KEYWORDS = new Map([ ['return', types_1.TokenType.БОЗГАШТ], ['throw', types_1.TokenType.ПАРТОФТАН], ['new', types_1.TokenType.НАВ], ['function', types_1.TokenType.ФУНКСИЯ], ['else', types_1.TokenType.ВАГАРНА], ['case', types_1.TokenType.ҲОЛАТ], ['default', types_1.TokenType.ПЕШФАРЗ], ['await', types_1.TokenType.ИНТИЗОР], ['in', types_1.TokenType.ДАР], ['this', types_1.TokenType.ИН], ['super', types_1.TokenType.СУПЕР], ['true', types_1.TokenType.ДУРУСТ], ['false', types_1.TokenType.НОДУРУСТ], ['null', types_1.TokenType.ХОЛӢ], ['static', types_1.TokenType.СТАТИКӢ], ['extends', types_1.TokenType.МЕРОС], ['implements', types_1.TokenType.ТАТБИҚ], ['public', types_1.TokenType.ҶАМЪИЯТӢ], ['private', types_1.TokenType.ХОСУСӢ], ['protected', types_1.TokenType.МУҲОФИЗАТШУДА], ['abstract', types_1.TokenType.МАВҲУМ], ['readonly', types_1.TokenType.ТАНҲОХОНӢ], ['keyof', types_1.TokenType.КАЛИДҲОИ], ['unique', types_1.TokenType.БЕНАЗИР], ]); Parser.MAX_NESTING = 500; /** Words that are the yield operator inside a generator body. */ Parser.YIELD_KEYWORDS = new Set(['ҳосил', 'yield']); /** Tokens after which `ҳосил` has no operand: `тағ х = ҳосил;`, `ф(ҳосил)`. */ Parser.YIELD_TERMINATORS = new Set([ types_1.TokenType.RIGHT_PAREN, types_1.TokenType.RIGHT_BRACKET, types_1.TokenType.RIGHT_BRACE, types_1.TokenType.COMMA, types_1.TokenType.SEMICOLON, types_1.TokenType.COLON, types_1.TokenType.EOF, ]); /** Words starting a do-while loop when a `{` follows: `кун { … } то (…);`. */ Parser.DO_KEYWORDS = new Set(['кун', 'do']); /** Words starting an enum when a name and `{` follow: `шумориш Ранг { … }`. */ Parser.ENUM_KEYWORDS = new Set(['шумориш', 'enum']); /** Statements that JavaScript does not allow as the body of a label. */ Parser.DECLARATION_TYPES = new Set([ 'VariableDeclaration', 'VariableDeclarationList', 'FunctionDeclaration', 'ClassDeclaration', 'InterfaceDeclaration', 'TypeAlias', 'NamespaceDeclaration', 'ImportDeclaration', 'ExportDeclaration', 'EnumDeclaration', ]); /** `модул` / `module` after `эълон`: an ambient module (`эълон модул "ном" {…}`). */ Parser.MODULE_KEYWORDS = new Set(['модул', 'module']); /** `глобалӣ` / `global` after `эълон`: global declarations (`эълон глобалӣ {…}`). */ Parser.GLOBAL_KEYWORDS = new Set(['глобалӣ', 'global']); /** Declarations that may follow `эълон`. */ Parser.AMBIENT_DECLARATION_TOKENS = new Set([ types_1.TokenType.СОБИТ, types_1.TokenType.ТАҒЙИРЁБАНДА, types_1.TokenType.ФУНКСИЯ, types_1.TokenType.ҲАМЗАМОН, types_1.TokenType.СИНФ, types_1.TokenType.МАВҲУМ, types_1.TokenType.НОМФАЗО, types_1.TokenType.ИНТЕРФЕЙС, types_1.TokenType.НАВЪ, ]); /** `истифода` / `using`, the start of a using declaration. */ Parser.USING_KEYWORDS = new Set(['истифода', 'using']); Parser.ASSIGNMENT_OPERATORS = [ types_1.TokenType.ASSIGN, types_1.TokenType.PLUS_ASSIGN, types_1.TokenType.MINUS_ASSIGN, types_1.TokenType.MULTIPLY_ASSIGN, types_1.TokenType.DIVIDE_ASSIGN, types_1.TokenType.MODULO_ASSIGN, types_1.TokenType.EXPONENT_ASSIGN, types_1.TokenType.BITWISE_AND_ASSIGN, types_1.TokenType.BITWISE_OR_ASSIGN, types_1.TokenType.BITWISE_XOR_ASSIGN, types_1.TokenType.LEFT_SHIFT_ASSIGN, types_1.TokenType.RIGHT_SHIFT_ASSIGN, types_1.TokenType.UNSIGNED_RIGHT_SHIFT_ASSIGN, types_1.TokenType.NULLISH_ASSIGN, types_1.TokenType.OR_ASSIGN, types_1.TokenType.AND_ASSIGN, ]; Parser.UNARY_KEYWORDS = new Set([ 'typeof', 'void', 'delete', ]); /** Binary operators other than `<`, `>`, `+` and `-` (see `canFollowTypeArguments`). */ Parser.BINARY_OPERATOR_TOKENS = new Set([ types_1.TokenType.NULLISH_COALESCING, types_1.TokenType.OR, types_1.TokenType.AND, types_1.TokenType.BITWISE_OR, types_1.TokenType.BITWISE_XOR, types_1.TokenType.BITWISE_AND, types_1.TokenType.EQUAL, types_1.TokenType.NOT_EQUAL, types_1.TokenType.STRICT_EQUAL, types_1.TokenType.STRICT_NOT_EQUAL, types_1.TokenType.LESS_EQUAL, types_1.TokenType.GREATER_EQUAL, types_1.TokenType.LEFT_SHIFT, types_1.TokenType.RIGHT_SHIFT, types_1.TokenType.UNSIGNED_RIGHT_SHIFT, types_1.TokenType.MULTIPLY, types_1.TokenType.DIVIDE, types_1.TokenType.MODULO, types_1.TokenType.EXPONENT, types_1.TokenType.ДАР, types_1.TokenType.ЧУН, types_1.TokenType.БАРМЕСОЁ, ]); /** Words that are binary operators: `in`, `instanceof`, `as`, `satisfies`. */ Parser.BINARY_OPERATOR_WORDS = new Set([ 'in', 'instanceof', 'as', 'satisfies', ]); /** Punctuation and literals that can start an operand. */ Parser.OPERAND_START_TOKENS = new Set([ types_1.TokenType.NUMBER, types_1.TokenType.STRING, types_1.TokenType.TEMPLATE_LITERAL, types_1.TokenType.REGEX, types_1.TokenType.PRIVATE_NAME, types_1.TokenType.LEFT_PAREN, types_1.TokenType.LEFT_BRACKET, types_1.TokenType.LEFT_BRACE, types_1.TokenType.NOT, types_1.TokenType.BITWISE_NOT, types_1.TokenType.INCREMENT, types_1.TokenType.DECREMENT, types_1.TokenType.PLUS, types_1.TokenType.MINUS, types_1.TokenType.LESS_THAN, types_1.TokenType.DIVIDE, types_1.TokenType.DIVIDE_ASSIGN, types_1.TokenType.AT, ]); /** Expressions that only assert a type (or fix type arguments): erased in the output. */ Parser.ASSERTION_TYPES = new Set([ 'AsExpression', 'TypeAssertion', 'SatisfiesExpression', 'NonNullExpression', 'InstantiationExpression', ]); /** `мавқуф` / `defer`, which defers an import (TypeScript 5.9 `import defer`). */ Parser.DEFER_KEYWORDS = new Set(['мавқуф', 'defer']); /** Tokens after `синф` that start a class without a name. */ Parser.ANONYMOUS_CLASS_FOLLOWERS = new Set([ types_1.TokenType.LEFT_BRACE, types_1.TokenType.МЕРОС, types_1.TokenType.ТАТБИҚ, types_1.TokenType.LESS_THAN, ]); Parser.BUILTIN_IDENTIFIER_TYPES = new Set([ types_1.TokenType.ВАЪДА, // Promise, as a value: `нав Ваъда(…)`, `Ваъда.all(…)` types_1.TokenType.ЧОП, types_1.TokenType.САБТ, types_1.TokenType.ХАТО, types_1.TokenType.ОГОҲӢ, types_1.TokenType.МАЪЛУМОТ, types_1.TokenType.ИСФТИ, types_1.TokenType.ТАСДИҚ, types_1.TokenType.ҚАЙД, types_1.TokenType.ҚАЙДАСЛ, types_1.TokenType.ВАҚТ, types_1.TokenType.ВАҚТСАБТ, types_1.TokenType.ВАҚТОХИР, types_1.TokenType.ҶАДВАЛ, types_1.TokenType.ФЕҲРИСТ, types_1.TokenType.XMLФЕҲРИСТ, types_1.TokenType.ПАЙҶО, types_1.TokenType.ПОЛИЗ, types_1.TokenType.ГУРУҲ, types_1.TokenType.ГУРУҲОХИР, types_1.TokenType.ГУРУҲПӮШИДА, types_1.TokenType.РӮЙХАТ, types_1.TokenType.ИЛОВА, types_1.TokenType.БАРОВАРДАН, types_1.TokenType.ДАРОЗӢ, types_1.TokenType.ХАРИТА, types_1.TokenType.ФИЛТР, types_1.TokenType.КОФТАН, types_1.TokenType.ГИРИФТАН, // Allow 'гирифтан' as identifier (common method name) // String methods types_1.TokenType.САТРМЕТОДҲО, types_1.TokenType.ДАРОЗИИСАТР, types_1.TokenType.ПАЙВАСТАН, types_1.TokenType.ҶОЙИВАЗКУНӢ, types_1.TokenType.ҶУДОКУНӢ, types_1.TokenType.КАЛИДҲО, types_1.TokenType.ҚИМАТҲО, types_1.TokenType.МАТЕМАТИКА, types_1.TokenType.ҶАМЪ, types_1.TokenType.ТАРҲ, types_1.TokenType.ЗАРБ, types_1.TokenType.ТАҚСИМ, types_1.TokenType.ҲОЛАТ, // Control flow keywords that can be used as property names types_1.TokenType.ТО, types_1.TokenType.АЗ, types_1.TokenType.ДАР, // Contextual Keywords: Primitive and special types // These can be used as identifiers in value contexts but act as keywords in type contexts types_1.TokenType.РАҚАМ, types_1.TokenType.САТР, types_1.TokenType.МАНТИҚӢ, types_1.TokenType.ХОЛӢ, types_1.TokenType.ОБЪЕКТ, // Contextual: can be used as variable name types_1.TokenType.ҲАР, // Contextual: any type types_1.TokenType.НОШИНОС, // Contextual: unknown type types_1.TokenType.АБАДАН, // Contextual: never type types_1.TokenType.БЕДЖАВОБ, // Contextual: void type types_1.TokenType.РАМЗ, // Contextual: symbol type types_1.TokenType.КАЛОНРАҚАМ, // Contextual: bigint type // Contextual Keywords: Type operators and utilities types_1.TokenType.НАВЪ, // Contextual: type keyword types_1.TokenType.КАЛИДҲОИ, // Contextual: keyof operator types_1.TokenType.НАВЪИ, // Contextual: typeof operator types_1.TokenType.САБТ_НАВЪ, // Contextual: typeof/type alias types_1.TokenType.ГИРИФТАН_НАВЪ, // Contextual: ReturnType utility types_1.TokenType.ҲАЗФ, // Contextual: Omit utility types_1.TokenType.ХОРИҶ, // Contextual: Exclude utility types_1.TokenType.ИСТИХРОҶ, // Contextual: Extract utility types_1.TokenType.БЕНАЛИӢ, // Contextual: Awaited utility types_1.TokenType.НАВЪИ_БОЗГАШТ, // Contextual: ReturnType types_1.TokenType.ПАРАМЕТРҲО, // Contextual: Parameters types_1.TokenType.НАВЪИ_НАМУНА, // Contextual: InstanceType types_1.TokenType.ПАРАМЕТРҲОИ_КОНСТРУКТОР, // Contextual: ConstructorParameters types_1.TokenType.НАВЪИ_ПАРАМЕТРИ_ИН, // Contextual: ThisParameterType types_1.TokenType.ИНТИЗОРШУДА, // Contextual: Awaited type // Type declaration keywords (contextual) types_1.TokenType.ЯКХЕЛА, // Contextual: extends keyword types_1.TokenType.МЕРОС, // Contextual: inheritance types_1.TokenType.ТАТБИҚ, // Contextual: implements types_1.TokenType.СУПЕР, // Contextual: super (can appear in expressions) types_1.TokenType.КОНСТРУКТОР, // Contextual: constructor types_1.TokenType.ХОСУСӢ, // Contextual: private types_1.TokenType.МУҲОФИЗАТШУДА, // Contextual: protected types_1.TokenType.ҶАМЪИЯТӢ, // Contextual: public types_1.TokenType.СТАТИКӢ, // Contextual: static types_1.TokenType.МАВҲУМ, // Contextual: abstract types_1.TokenType.НОМФАЗО, // Contextual: namespace types_1.TokenType.ИНФЕР, // Contextual: infer types_1.TokenType.ХУЛОСА, // Contextual: conclusion/end types_1.TokenType.ТАНҲОХОНӢ, // Contextual: readonly types_1.TokenType.БЕНАЗИР, // Contextual: unique types_1.TokenType.АСТ, // Contextual: is type guard types_1.TokenType.БАРМЕСОЁ, // Contextual: satisfies operator types_1.TokenType.ҚИСМӢ, // Contextual: Partial utility types_1.TokenType.ҲАТМӢ, // Contextual: Required utility types_1.TokenType.ТАНҲОХОН, // Contextual: Readonly utility ]); Parser.PARAMETER_MODIFIERS = new Map([ [types_1.TokenType.ҶАМЪИЯТӢ, 'public'], [types_1.TokenType.ХОСУСӢ, 'private'], [types_1.TokenType.МУҲОФИЗАТШУДА, 'protected'], [types_1.TokenType.ТАНҲОХОНӢ, 'readonly'], ]); /** Tokens that may follow a complete type, so they cannot start the operand of `танҳохонӣ`. */ Parser.TYPE_FOLLOWERS = new Set([ types_1.TokenType.ASSIGN, types_1.TokenType.SEMICOLON, types_1.TokenType.COMMA, types_1.TokenType.COLON, types_1.TokenType.QUESTION, types_1.TokenType.GREATER_THAN, types_1.TokenType.RIGHT_SHIFT, types_1.TokenType.UNSIGNED_RIGHT_SHIFT, types_1.TokenType.RIGHT_PAREN, types_1.TokenType.RIGHT_BRACKET, types_1.TokenType.RIGHT_BRACE, types_1.TokenType.LEFT_BRACE, types_1.TokenType.BITWISE_OR, types_1.TokenType.BITWISE_AND, types_1.TokenType.ARROW, types_1.TokenType.DOT, types_1.TokenType.LESS_THAN, types_1.TokenType.МЕРОС, types_1.TokenType.EOF, ]); Parser.TYPE_PARAMETER_MODIFIER_WORDS = new Map([ ['берун', 'out'], ['const', 'const'], ['in', 'in'], ['out', 'out'], ]); /** Modifier keywords of class members only. */ Parser.CLASS_ONLY_MODIFIERS = new Set([ types_1.TokenType.ҶАМЪИЯТӢ, types_1.TokenType.ХОСУСӢ, types_1.TokenType.МУҲОФИЗАТШУДА, types_1.TokenType.СТАТИКӢ, types_1.TokenType.МАВҲУМ, types_1.TokenType.ҲАМЗАМОН, ]); /** Tokens after which a modifier word is a modifier, besides names (see `modifierApplies`). */ Parser.MODIFIER_FOLLOWERS = new Set([ types_1.TokenType.LEFT_BRACKET, types_1.TokenType.LEFT_BRACE, types_1.TokenType.MULTIPLY, types_1.TokenType.SPREAD, types_1.TokenType.STRING, types_1.TokenType.NUMBER, types_1.TokenType.PRIVATE_NAME, ]); Parser.ACCESSOR_NAME_TOKENS = new Set([ types_1.TokenType.PRIVATE_NAME, types_1.TokenType.STRING, types_1.TokenType.NUMBER, ]); /** `бознавис` / `override` (override), also on parameter properties. */ Parser.OVERRIDE_KEYWORDS = new Set([ 'бознавис', 'override', ]); /** `дастрасӣ` / `accessor`: an auto-accessor field. */ Parser.ACCESSOR_KEYWORDS = new Set([ 'дастрасӣ', 'accessor', ]); /** `эълон` / `declare`: an ambient declaration or a declared class field. */ Parser.DECLARE_KEYWORDS = new Set(['эълон', 'declare']); Parser.STATEMENT_KEYWORDS = new Set([ types_1.TokenType.ТАҒЙИРЁБАНДА, types_1.TokenType.СОБИТ, types_1.TokenType.ФУНКСИЯ, types_1.TokenType.АГАР, types_1.TokenType.ТО, // while keyword types_1.TokenType.БАРОИ, types_1.TokenType.БОЗГАШТ, types_1.TokenType.СИНФ, types_1.TokenType.МАВҲУМ, types_1.TokenType.ИНТЕРФЕЙС, types_1.TokenType.НОМФАЗО, types_1.TokenType.КӮШИШ, types_1.TokenType.ИНТИХОБ, types_1.TokenType.ПАРТОФТАН, types_1.TokenType.ШИКАСТАН, types_1.TokenType.ДАВОМ, types_1.TokenType.ВОРИД, types_1.TokenType.СОДИР, types_1.TokenType.ҲАМЗАМОН, ]); }, {"./types":"types.js","./lexer":"lexer.js","./handlers/import-handler":"handlers/import-handler.js","./handlers/declaration-handler":"handlers/declaration-handler.js","./handlers/loop-handler":"handlers/loop-handler.js"}, ], "playground/console.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.createPlaygroundConsole = createPlaygroundConsole; /** * The console a program run in the playground prints with (`чоп`, `чоп.сабт`, * `чоп.хато`, …): values with SomonScript's names (src/runtime/format.ts), as * `somon run` prints them, sent to the page line by line. */ const format_1 = require("../runtime/format"); /** What `чоп.тасдиқ(шарт, …)` prints when the condition is false. */ const ASSERTION_FAILED = 'Тасдиқ нашуд'; function createPlaygroundConsole(print, now = Date.now) { let indent = ''; const counts = new Map(); const timers = new Map(); const write = (stream, args) => { const text = (0, format_1.formatArgs)(args); print(stream, indent === '' ? text : text.replace(/^/gm, indent)); }; const log = (...args) => write('log', args); const warn = (...args) => write('warn', args); const error = (...args) => write('error', args); const elapsed = (label) => `${label}: ${now() - (timers.get(label) ?? now())}ms`; return { log, info: log, debug: log, trace: log, warn, error, dir: (value) => write('log', [(0, format_1.formatValue)(value)]), table: (value) => write('log', [value]), assert(condition, ...args) { if (condition) return; if (typeof args[0] === 'string') warn(`${ASSERTION_FAILED}: ${args[0]}`, ...args.slice(1)); else warn(args.length > 0 ? `${ASSERTION_FAILED}:` : ASSERTION_FAILED, ...args); }, group(...labels) { if (labels.length > 0) log(...labels); indent += ' '; }, groupCollapsed(...labels) { this.group(...labels); }, groupEnd() { indent = indent.slice(2); }, count(label = 'default') { const count = (counts.get(label) ?? 0) + 1; counts.set(label, count); log(`${label}: ${count}`); }, countReset(label = 'default') { counts.delete(label); }, time(label = 'default') { timers.set(label, now()); }, timeLog(label = 'default', ...args) { log(elapsed(label), ...args); }, timeEnd(label = 'default') { log(elapsed(label)); timers.delete(label); }, clear() { // The page keeps what was printed }, }; } }, {"../runtime/format":"runtime/format.js"}, ], "playground/run.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.PlaygroundModuleError = exports.OUTPUT_LINES = exports.PROTOCOL = void 0; exports.runProgram = runProgram; /** * Compiling and running a program in the playground (src/playground/worker.ts * runs it in a Web Worker; the tests run it in Node.js): the diagnostics of * the compiler, what the program prints, its errors placed on the lines of * the source, and when it is done. The page (playground/src/app.js) shows * the events it sends; it stops a program that runs too long by ending the * worker. * * Input comes from the page's input field: `хондан()` and `хонданиРақам()` * read its lines in order, as from a file redirected to `somon run`. * * With `trace`, the program records its steps (src/runtime/trace.ts) and the * page is sent them before the program's end, for a lesson to replay it. */ const browser_1 = require("../browser"); const catalog_1 = require("../diagnostics/catalog"); const format_1 = require("../diagnostics/format"); const codegen_1 = require("../codegen"); const errors_1 = require("../runtime/errors"); const input_1 = require("../runtime/input"); const report_1 = require("../runtime/report"); const trace_1 = require("../runtime/trace"); const console_1 = require("./console"); /** The version of these events, for pages that bundle another build of the worker. */ exports.PROTOCOL = 2; /** How many lines of output the page is sent. */ exports.OUTPUT_LINES = 1000; /** * The code runs inside a function, so that its declarations do not replace * the worker's globals. On its first line, so that the lines stay the same. */ const PREFIX = '(function () {'; const SUFFIX = '\n}).call(module.exports);\n'; /** A module the program imports: the playground has only the one file. */ class PlaygroundModuleError extends Error { constructor(specifier) { super(`The playground cannot import '${specifier}'`); this.name = 'PlaygroundModuleError'; this.specifier = specifier; } } exports.PlaygroundModuleError = PlaygroundModuleError; function runProgram(request, host) { const { source, language } = request; const result = (0, browser_1.compile)(source, { language, mappings: true, learningMode: request.learningMode, trace: Boolean(request.trace), }); // Given with `language` const diagnostics = result.diagnostics; const errors = diagnostics.filter(d => d.severity === 'error'); if (errors.length > 0) { host.post({ type: 'notCompiled', diagnostics: diagnostics.map(d => shown(d, language, source)), summary: (0, format_1.formatFailure)(errors.length, language), }); return { fail: () => undefined }; } host.post({ type: 'compiled', code: result.code, diagnostics: diagnostics.map(d => shown(d, language, source)), }); // None when TypeScript, which a page may have loaded, lowered the code return new Run(request, host, result.mappings ?? []).start(result.code); } function shown(diagnostic, language, source) { return { severity: diagnostic.severity, line: diagnostic.line, text: (0, format_1.formatDiagnostic)(diagnostic, { language, source }), }; } class Run { constructor(request, host, mappings) { this.finished = false; this.lines = 0; /** Prompts of the input functions, printed with what comes next, as in a terminal. */ this.prompt = ''; /** Timers the program set and that have not run or been cleared. */ this.active = new Set(); this.file = ''; /** How many `output` events were sent. */ this.outputs = 0; this.traceSent = false; this.request = request; this.host = host; this.mappings = mappings; } start(code) { this.prepareScope(); try { const script = this.host.script(PREFIX + code + SUFFIX); this.file = script.file; script.run(); } catch (error) { this.fail(error); return this; } this.checkDone(); return this; } fail(error) { if (this.finished) return; this.flushPrompt(); this.finished = true; const { language, source } = this.request; const diagnostic = (0, report_1.runtimeDiagnostic)(explain(error), language, this.placeOf(error), source); this.tracer?.error(diagnostic.line); this.sendTrace(); this.host.post({ type: 'runtimeError', text: (0, format_1.formatDiagnostic)(diagnostic, { language, source, runtime: true }), line: diagnostic.line, }); this.host.post({ type: 'done' }); } /** Where in the source an error happened: the first frame of the program, mapped back. */ placeOf(error) { const stack = error?.stack; if (typeof stack !== 'string' || this.file === '') return undefined; const location = (0, errors_1.locateError)(stack, this.file); if (!location) return undefined; const column = location.line === 1 ? location.column - PREFIX.length : location.column; const original = (0, codegen_1.originalPosition)(this.mappings, location.line, column - 1); if (!original) return undefined; return { line: original.line, column: original.column + 1, functionName: location.functionName, }; } prepareScope() { const { scope, timers } = this.host; scope.console = (0, console_1.createPlaygroundConsole)((stream, text) => this.print(stream, text)); const input = inputFrom(this.request.input, text => { this.prompt += text; }); scope[input_1.INPUT_GLOBAL] = (0, input_1.createInput)(input, this.request.language); const module = { exports: {} }; scope.module = module; scope.exports = module.exports; scope.require = (specifier) => { throw new PlaygroundModuleError(specifier); }; scope.setTimeout = (callback, ms, ...args) => { const id = timers.setTimeout(() => { this.active.delete(id); this.guard(callback, args); this.checkDone(); }, ms); this.active.add(id); return id; }; scope.setInterval = (callback, ms, ...args) => { const id = timers.setInterval(() => this.guard(callback, args), ms); this.active.add(id); return id; }; scope.clearTimeout = (id) => this.clear(id, timers.clearTimeout); scope.clearInterval = (id) => this.clear(id, timers.clearInterval); if (this.request.trace) { const { maxSteps } = this.request.trace === true ? {} : this.request.trace; this.tracer = new trace_1.Tracer({ maxSteps, printed: () => this.outputs, full: () => this.sendTrace(), }); scope[trace_1.TRACE_GLOBAL] = this.tracer; } } /** The steps so far, once: at the program's end, its error, or when no more are recorded. */ sendTrace() { if (!this.tracer || this.traceSent) return; this.traceSent = true; this.host.post({ type: 'trace', steps: this.tracer.steps, truncated: this.tracer.truncated }); } clear(id, clear) { if (this.active.delete(id)) clear(id); this.checkDone(); } /** Runs a callback of the program; what it throws ends the program. */ guard(callback, args) { if (this.finished || typeof callback !== 'function') return; try { callback(...args); } catch (error) { this.fail(error); } } /** The program is done when it set no timer that is still to run, after its promises settle. */ checkDone() { if (this.finished) return; this.host.timers.setTimeout(() => { if (this.finished || this.active.size > 0) return; this.flushPrompt(); this.finished = true; this.sendTrace(); this.host.post({ type: 'done' }); }, 0); } flushPrompt() { if (this.prompt !== '') this.print('log', ''); } print(stream, printed) { if (this.finished || this.lines >= exports.OUTPUT_LINES) return; const text = this.prompt + printed; this.prompt = ''; const lines = text.split('\n'); const room = exports.OUTPUT_LINES - this.lines; this.lines += lines.length; this.outputs++; this.host.post({ type: 'output', stream, text: lines.slice(0, room).join('\n') }); if (this.lines >= exports.OUTPUT_LINES) this.host.post({ type: 'outputLimit', lines: exports.OUTPUT_LINES }); } } /** What an error of the program is about; an import is the playground's limit. */ function explain(error) { if (error instanceof PlaygroundModuleError) { // As the program names it: the code generator adds `.js` const name = error.specifier.replace(/\.js$/, ''); return { message: (0, catalog_1.message)('RUNTIME_NO_MODULES', { name }) }; } return (0, errors_1.explainError)(error); } /** The input field as the input of the program: all of it at once, then its end. */ function inputFrom(text, write) { let read = false; return { read: () => { if (read) return null; read = true; return text; }, write, interactive: false, }; } }, {"../browser":"browser.js","../diagnostics/catalog":"diagnostics/catalog.js","../diagnostics/format":"diagnostics/format.js","../codegen":"codegen.js","../runtime/errors":"runtime/errors.js","../runtime/input":"runtime/input.js","../runtime/report":"runtime/report.js","../runtime/trace":"runtime/trace.js","./console":"playground/console.js"}, ], "playground/worker.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); /** * The Web Worker of the playground (scripts/build-playground.js bundles it * into the page): runs one program the page sends (src/playground/run.ts) and * posts back what happens. The program is a script from a Blob URL, run with * `importScripts`, so that its stack frames give its lines in every browser. * The page ends the worker when the program is done or runs too long. */ const run_1 = require("./run"); // The bundle defines `global` as the global object const scope = global; // Taken before the program runs: it may declare names of its own const post = scope.postMessage.bind(scope); const timers = { setTimeout: scope.setTimeout.bind(scope), clearTimeout: scope.clearTimeout.bind(scope), setInterval: scope.setInterval.bind(scope), clearInterval: scope.clearInterval.bind(scope), }; const importScripts = scope.importScripts.bind(scope); let program; scope.addEventListener('unhandledrejection', event => { event.preventDefault(); program?.fail(event.reason); }); scope.addEventListener('error', event => { event.preventDefault(); program?.fail(event.error ?? event.message); }); scope.onmessage = event => { // One program per worker scope.onmessage = null; program = (0, run_1.runProgram)(event.data, { post, timers, scope: scope, script: code => { const file = URL.createObjectURL(new Blob([code], { type: 'text/javascript' })); return { file, run: () => importScripts(file) }; }, }); }; }, {"./run":"playground/run.js"}, ], "runtime/errors.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.tajikNames = tajikNames; exports.explainError = explainError; exports.locateError = locateError; exports.columnOfName = columnOfName; exports.readsByIndex = readsByIndex; /** * What an error of a running program is about, in SomonScript's words: the * JavaScript engine's message ("Cannot read properties of undefined * (reading 'length')") read into a message of the diagnostics catalog, with * JavaScript's names given back their Tajik ones (`length` → `дарозӣ`, * `console` → `чоп`). The place in the `.som` file comes from the stack of * the error (`locateError`), which Node.js maps through the source map. * * No Node.js API is used: the playground explains errors with it too. */ const builtin_names_1 = require("../builtin-names"); const catalog_1 = require("../diagnostics/catalog"); const format_1 = require("./format"); const input_1 = require("./input"); /** JavaScript names of built-ins and the Tajik names a program writes for them. */ const TAJIK_NAMES = (() => { const names = new Map([ ['console', 'чоп'], ['Math', 'математика'], ['Object', 'объект'], ['Array', 'рӯйхат'], ['String', 'сатр'], ['Promise', 'Ваъда'], ['Error', 'Хато'], ]); for (const [tajik, js] of builtin_names_1.BUILTIN_MAPPINGS) { if (builtin_names_1.MEMBER_ALIASES.has(tajik) && !names.has(js)) names.set(js, tajik); } return names; })(); /** `console.log` → `чоп.сабт`, `р.length` → `р.дарозӣ`; other names stay. */ function tajikNames(text) { return text.replace(/[\p{L}_$][\p{L}\p{N}_$]*/gu, name => TAJIK_NAMES.get(name) ?? name); } /** `undefined` → `беқимат`, `null` → `холӣ`. */ function valueName(value) { return value === 'null' ? 'холӣ' : 'беқимат'; } /** Messages of the engine (V8, and the wording of other engines where it differs). */ const PATTERNS = [ { // V8: Cannot read properties of undefined (reading 'length'); Firefox: x is undefined test: /^Cannot read propert(?:y|ies) of (undefined|null)(?: $reading '(.*)'$)?/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_READ_OF_NOTHING', { property: tajikNames(match[2] ?? '?'), value: valueName(match[1]), }), hint: (0, catalog_1.message)('CHECK_VALUE', { value: valueName(match[1]) }), }), }, { test: /^Cannot set propert(?:y|ies) of (undefined|null)(?: $setting '(.*)'$)?/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_WRITE_TO_NOTHING', { property: tajikNames(match[2] ?? '?'), value: valueName(match[1]), }), hint: (0, catalog_1.message)('CHECK_VALUE', { value: valueName(match[1]) }), }), }, { test: /^(.+) is not defined$/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_NOT_DEFINED', { name: tajikNames(match[1]) }) }), }, { test: /^Cannot access '(.+)' before initialization$/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_BEFORE_DECLARATION', { name: tajikNames(match[1]) }), hint: (0, catalog_1.message)('DECLARE_BEFORE_USE'), }), }, { test: /^(.+) is not a function$/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_NOT_A_FUNCTION', { name: tajikNames(match[1]) }), }), }, { test: /^(.+) is not a constructor$/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_NOT_A_CONSTRUCTOR', { name: tajikNames(match[1]) }), }), }, { test: /^(.+) is not iterable$/, explain: match => ({ message: (0, catalog_1.message)('RUNTIME_NOT_ITERABLE', { name: tajikNames(match[1]) }), }), }, { test: /^Maximum call stack size exceeded$|^too much recursion$/, explain: () => ({ message: (0, catalog_1.message)('RUNTIME_STACK_OVERFLOW'), hint: (0, catalog_1.message)('STOP_CONDITION'), }), }, { test: /^Invalid array length$/, explain: () => ({ message: (0, catalog_1.message)('RUNTIME_INVALID_ARRAY_LENGTH') }), }, { test: /^Assignment to constant variable\.?$/, explain: () => ({ message: (0, catalog_1.message)('RUNTIME_CONST_ASSIGNMENT') }), }, ]; /** Errors of the engine; anything else a program throws is its own. */ const ENGINE_ERRORS = new Set([ 'TypeError', 'ReferenceError', 'RangeError', 'SyntaxError', 'InternalError', ]); /** * What `thrown` is about. The engine's errors are explained; what the program * throws itself (`партофтан нав Хато("…")`, or any value) keeps its message. */ function explainError(thrown) { if (thrown instanceof input_1.InputError) return explainInputError(thrown); if (!(thrown instanceof Error) && !isErrorLike(thrown)) { return { message: (0, catalog_1.message)('RUNTIME_THROWN', { message: (0, format_1.formatValue)(thrown) }) }; } const { name, message: text } = thrown; if (ENGINE_ERRORS.has(name)) { for (const pattern of PATTERNS) { const match = pattern.test.exec(text); if (match) return pattern.explain(match); } return { message: (0, catalog_1.message)('RUNTIME_ERROR', { name, message: text }), hint: (0, catalog_1.message)('SHOW_STACK'), }; } // Node.js's own errors (`ENOENT: no such file …`) carry a code; the program's do not if (typeof thrown.code === 'string') { return { message: (0, catalog_1.message)('RUNTIME_ERROR', { name, message: text }), hint: (0, catalog_1.message)('SHOW_STACK'), }; } return { message: (0, catalog_1.message)('RUNTIME_THROWN', { message: text }) }; } /** The input ended, or held no number where `хонданиРақам` read one. */ function explainInputError(error) { const name = error.functionName; return error.kind === 'ended' ? { message: (0, catalog_1.message)('RUNTIME_INPUT_ENDED', { name }), hint: (0, catalog_1.message)('INPUT_LINES') } : { message: (0, catalog_1.message)('RUNTIME_INPUT_NOT_A_NUMBER', { name, text: error.text }), hint: (0, catalog_1.message)('INPUT_NUMBER'), }; } /** An error of another realm (a worker, a vm context): its own Error class. */ function isErrorLike(value) { return (typeof value === 'object' && value !== null && typeof value.name === 'string' && typeof value.message === 'string' && typeof value.stack === 'string'); } /** * The first place a stack names (`at ф (/дар/барнома.som:2:15)`) in a `.som` * file, or in the file `file` when given (the playground's program). */ function locateError(stack, file) { for (const line of stack.split('\n')) { // V8: ` at ф (/дар/б.som:2:15)`; Firefox and Safari: `ф@/дар/б.som:2:15` const frame = /^\s*at (?:(.*?) $)?(.+?):(\d+):(\d+)$?$/.exec(line) ?? /^([^@\s]*)@(.+?):(\d+):(\d+)$/.exec(line); if (frame && (frame[2].endsWith('.som') || frame[2] === file)) { const location = { file: frame[2], line: Number(frame[3]), column: Number(frame[4]), }; // `Object.барнома.som` is a module of the bundle, not a function const functionName = frame[1]?.endsWith('.som') ? undefined : frame[1]?.split(/[./]/).pop(); if (functionName && /^[\p{L}_$][\p{L}\p{N}_$]*$/u.test(functionName)) { location.functionName = functionName; } return location; } } return undefined; } /** * The column of the name an explained error is about on its line of code, at * or after `column` (source maps name the statement): `дарозӣ` of * `р[10].дарозӣ`, the callee of a call, the function of endless recursion. * `column` when the line does not have it. */ function columnOfName(code, column, explained, functionName) { const params = explained.message.params; // Endless recursion: the call of the function the stack names const called = explained.message.id === 'RUNTIME_STACK_OVERFLOW' ? functionName : undefined; const name = String(params.property ?? params.name ?? called ?? ''); // `чоп.сабтт` is not a function: its last part is on the line const last = name.split('.').pop(); if (last === '' || last === '?') return column; const index = code.indexOf(last, column - 1); return index === -1 ? column : index + 1; } /** Whether a line of code reads an element by index just before `column`: `р[10].дарозӣ`. */ function readsByIndex(code, column) { return /\]\s*\.?\s*$/.test(code.slice(0, Math.max(column - 1, 0))); } }, {"../builtin-names":"builtin-names.js","../diagnostics/catalog":"diagnostics/catalog.js","./format":"runtime/format.js","./input":"runtime/input.js"}, ], "runtime/format.js": [ function (module, exports, require) { "use strict"; /** * How `чоп(…)` and `чоп.сабт(…)` print values when a program runs with * `somon run` or in the playground: with SomonScript's own names, so the * learner who writes `дуруст` reads `дуруст`, not `true`. * * дуруст, нодуруст, холӣ, беқимат (true, false, null, undefined) * ғайрирақам, беохир, -беохир (NaN, Infinity, -Infinity) * * Strings print as they are at the top level and in double quotes inside * arrays and objects; arrays, objects, Map and Set look much as Node.js prints * them. Format strings (`чоп.сабт("%s: %d", а, б)`) work as in Node.js. * * No Node.js API is used: the browser bundle includes this module. Values the * formatter does not know (typed arrays, Promise, …) go to `fallback`. */ Object.defineProperty(exports, "__esModule", { value: true }); exports.VALUE_NAMES = void 0; exports.formatArgs = formatArgs; exports.formatValue = formatValue; exports.inspect = inspect; exports.formatNumber = formatNumber; /** SomonScript names of JavaScript's special values (docs/glossary.tj.md). */ exports.VALUE_NAMES = { true: 'дуруст', false: 'нодуруст', null: 'холӣ', undefined: 'беқимат', NaN: 'ғайрирақам', Infinity: 'беохир', }; /** Words the formatter prints around values. */ const WORDS = { function: 'функсия', class: 'синф', circular: 'даврӣ', array: 'рӯйхат', object: 'объект', emptyItems: (count) => `<${count} ҷои холӣ>`, moreItems: (count) => `... боз ${count} унсур`, getter: 'ҳисобшаванда', }; /** The line a console call prints for its arguments. */ function formatArgs(args, options = {}) { if (typeof args[0] === 'string' && args.length > 1 && args[0].includes('%')) { return formatWithSpecifiers(args[0], args.slice(1), options); } return args.map(arg => formatValue(arg, options)).join(' '); } /** One value as `чоп.сабт` prints it on its own: a string as it is. */ function formatValue(value, options = {}) { return typeof value === 'string' ? value : inspect(value, options); } /** A value as it appears inside an array or object: a string in quotes. */ function inspect(value, options = {}) { const context = { depth: options.depth ?? 6, fallback: options.fallback ?? defaultFallback, seen: [], }; return inspectAt(value, context, 0); } /** Longest line printed on one line; longer ones are broken up as Node.js does. */ const BREAK_LENGTH = 72; /** Array elements shown before `... боз N унсур`. */ const MAX_ARRAY_ITEMS = 100; function inspectAt(value, context, level) { if (value === null || (typeof value !== 'object' && typeof value !== 'function')) { return primitive(value); } if (typeof value === 'function') return functionName(value); if (context.seen.includes(value)) return `[${WORDS.circular}]`; const special = specialObject(value, context); if (special !== undefined) return special; if (level > context.depth) return Array.isArray(value) ? `[${WORDS.array}]` : `[${WORDS.object}]`; context.seen.push(value); try { return container(value, context, level); } finally { context.seen.pop(); } } function primitive(value) { switch (typeof value) { case 'string': return quote(value); case 'number': return formatNumber(value); case 'bigint': return `${value}n`; case 'boolean': return value ? exports.VALUE_NAMES.true : exports.VALUE_NAMES.false; case 'undefined': return exports.VALUE_NAMES.undefined; case 'symbol': return value.toString(); default: return exports.VALUE_NAMES.null; } } /** `NaN` → `ғайрирақам`, `-Infinity` → `-беохир`, `-0` → `-0`, others as JavaScript prints them. */ function formatNumber(value) { if (Number.isNaN(value)) return exports.VALUE_NAMES.NaN; if (value === Infinity) return exports.VALUE_NAMES.Infinity; if (value === -Infinity) return `-${exports.VALUE_NAMES.Infinity}`; if (Object.is(value, -0)) return '-0'; return String(value); } /** A string in double quotes, as SomonScript programs write them. */ function quote(text) { return JSON.stringify(text); } function functionName(fn) { const callable = fn; const name = typeof callable.name === 'string' ? callable.name : ''; const isClass = /^class[\s{]/.test(Function.prototype.toString.call(fn)); const word = isClass ? WORDS.class : WORDS.function; return name ? `[${word} ${name}]` : `[${word}]`; } /** Dates, errors and regular expressions print as one piece; undefined for other objects. */ function specialObject(value, context) { if (value instanceof Date) { return Number.isNaN(value.getTime()) ? String(value) : value.toISOString(); } if (value instanceof RegExp) return String(value); if (value instanceof Error) { // `Error` is spelt `Хато` in SomonScript; the stack is noise for a learner const name = value.name === 'Error' ? 'Хато' : value.name; return value.message ? `${name}: ${value.message}` : name; } if (isBoxedPrimitive(value)) return primitive(value.valueOf()); if (!isPlainContainer(value)) return context.fallback(value); return undefined; } function isBoxedPrimitive(value) { return value instanceof Number || value instanceof String || value instanceof Boolean; } /** Arrays, Map, Set and objects whose own properties are what they hold. */ function isPlainContainer(value) { if (Array.isArray(value) || value instanceof Map || value instanceof Set) return true; if (ArrayBuffer.isView(value) || value instanceof Promise) return false; if (value instanceof WeakMap || value instanceof WeakSet) return false; return true; } function container(value, context, level) { const inner = (item) => inspectAt(item, context, level + 1); if (Array.isArray(value)) return wrap('[', arrayItems(value, inner), ']', level); if (value instanceof Map) { const entries = [...value].map(([key, item]) => `${inner(key)} => ${inner(item)}`); return `Map(${value.size}) ${wrap('{', entries, '}', level)}`; } if (value instanceof Set) { return `Set(${value.size}) ${wrap('{', [...value].map(inner), '}', level)}`; } const items = objectItems(value, inner); const prefix = constructorPrefix(value); if (items.length === 0) return `${prefix}{}`; return `${prefix}${wrap('{', items, '}', level)}`; } /** Elements, with runs of holes as `<2 ҷои холӣ>` and at most 100 shown. */ function arrayItems(array, inner) { const items = []; let holes = 0; const shown = Math.min(array.length, MAX_ARRAY_ITEMS); for (let index = 0; index < shown; index++) { if (!(index in array)) { holes++; continue; } if (holes > 0) items.push(WORDS.emptyItems(holes)); holes = 0; items.push(inner(array[index])); } if (holes > 0) items.push(WORDS.emptyItems(holes)); if (array.length > shown) items.push(WORDS.moreItems(array.length - shown)); return items; } /** `ном: "Алӣ"` for every own enumerable property, symbols included. */ function objectItems(value, inner) { const items = []; for (const key of Reflect.ownKeys(value)) { const descriptor = Object.getOwnPropertyDescriptor(value, key); if (!descriptor?.enumerable) continue; const name = typeof key === 'symbol' ? `[${key.toString()}]` : propertyName(key); const shown = 'value' in descriptor ? inner(descriptor.value) : `[${WORDS.getter}]`; items.push(`${name}: ${shown}`); } return items; } /** Identifiers (Cyrillic ones included) as they are, other keys in quotes. */ function propertyName(key) { return /^[\p{ID_Start}$_][\p{ID_Continue}$‌‍]*$/u.test(key) ? key : quote(key); } /** `Корбар ` for instances of a class; nothing for plain objects. */ function constructorPrefix(value) { const prototype = Object.getPrototypeOf(value); if (prototype === null || prototype === Object.prototype) return ''; const name = prototype.constructor?.name; return typeof name === 'string' && name !== '' && name !== 'Object' ? `${name} ` : ''; } /** * `{ а: 1, б: 2 }` on one line when it is short and nothing in it spans * lines; otherwise one item per line, or, for short items, as many per line * as fit. */ function wrap(open, items, close, level) { if (items.length === 0) return `${open}${close}`; const oneLine = `${open} ${items.join(', ')} ${close}`; const multiLine = items.some(item => item.includes('\n')); if (!multiLine && oneLine.length + level * 2 <= BREAK_LENGTH) return oneLine; // Nested containers are indented by the container around them const indent = ' '; const lines = !multiLine && items.every(item => item.length <= 16) ? fill(items, level) : items; const body = lines.map(line => `${indent}${line.replace(/\n/g, `\n${indent}`)}`).join(',\n'); return `${open}\n${body}\n${close}`; } /** Short items several to a line, each line (indented for `level`) at most `BREAK_LENGTH` long. */ function fill(items, level) { const lines = []; let line = ''; for (const item of items) { const next = line === '' ? item : `${line}, ${item}`; if (line !== '' && (level + 1) * 2 + next.length + 1 > BREAK_LENGTH) { lines.push(line); line = item; } else { line = next; } } lines.push(line); return lines; } /** * `%s`, `%d`, `%i`, `%f`, `%j`, `%o`, `%O`, `%c` and `%%` as Node.js's * `util.format` reads them; arguments left over are appended. */ function formatWithSpecifiers(format, args, options) { let next = 0; const text = format.replace(/%([sdifjoOc%])/g, (match, letter) => { if (letter === '%') return '%'; if (next >= args.length) return match; return specifier(letter, args[next++], options); }); const rest = args.slice(next).map(arg => formatValue(arg, options)); return [text, ...rest].join(' '); } function specifier(letter, arg, options) { switch (letter) { case 's': return formatValue(arg, options); case 'd': case 'i': { if (typeof arg === 'bigint') return `${arg}n`; if (typeof arg === 'symbol') return exports.VALUE_NAMES.NaN; const number = Number(arg); return formatNumber(letter === 'i' ? Math.trunc(number) : number); } case 'f': return typeof arg === 'symbol' ? exports.VALUE_NAMES.NaN : formatNumber(Number.parseFloat(String(arg))); case 'j': return json(arg); case 'c': return ''; default: return inspect(arg, options); } } function json(value) { try { return String(JSON.stringify(value)); } catch { return `[${WORDS.circular}]`; } } function defaultFallback(value) { return Object.prototype.toString.call(value); } }, {}, ], "runtime/input.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.InputError = exports.INPUT_GLOBAL = void 0; exports.parseNumber = parseNumber; exports.createInput = createInput; /** * `хондан()` and `хонданиРақам()`: a line, or a number, the learner types or * the input of the program holds (`somon run барнома.som < вуруд.txt`, the * playground's input field). They are synchronous, so that a learner reads * input as they print output, without `ҳамзамон`/`интизор`. * * - A line is returned without its line break (`\n` or `\r\n`). * - A number may be written with a decimal point or comma (`2.5`, `2,5`). * What is no number is asked again when a person types the input, and is * an error when the input comes from a file or the playground: it cannot be * corrected there. * - At the end of the input both end the program with an error ("Вуруд тамом * шуд"): there is no line to return. * * Where the input comes from is the host's business (src/runtime/node-input.ts * for Node.js); no Node.js API is used here. */ const catalog_1 = require("../diagnostics/catalog"); /** * The global the run time puts the input functions in; programs that read * input take them from it (see `INPUT_PROLOGUE` in src/codegen.ts). */ exports.INPUT_GLOBAL = '__somonInput'; /** * The input ended, or a number was expected and something else came; its * message is English, src/runtime/errors.ts explains it in the learner's language. */ class InputError extends Error { constructor(kind, functionName, text = '') { super(kind === 'ended' ? `The input ended: ${functionName}() expected another line` : `'${text}' is not a number: ${functionName}() expected one`); this.name = 'InputError'; this.kind = kind; this.functionName = functionName; this.text = text; } } exports.InputError = InputError; /** A number as a learner may write it: `42`, `-3`, `2.5`, `2,5`. */ function parseNumber(text) { const trimmed = text.trim(); if (!/^[-+]?(\d+([.,]\d*)?|[.,]\d+)(e[-+]?\d+)?$/i.test(trimmed)) return undefined; return Number(trimmed.replace(',', '.')); } /** `хондан` and `хонданиРақам` reading from `host`. */ function createInput(host, language) { let buffered = ''; let ended = false; const readLine = (functionName, prompt) => { if (prompt !== undefined) host.write(String(prompt)); for (;;) { const newline = buffered.indexOf('\n'); if (newline !== -1) { const line = buffered.slice(0, newline); buffered = buffered.slice(newline + 1); return line.endsWith('\r') ? line.slice(0, -1) : line; } if (ended) { if (buffered === '') throw new InputError('ended', functionName); // The last line, without a line break after it const line = buffered; buffered = ''; return line; } const piece = host.read(); if (piece === null) ended = true; else buffered += piece; } }; return { хондан: (prompt) => readLine('хондан', prompt), хонданиРақам: (prompt) => { for (;;) { const text = readLine('хонданиРақам', prompt); const value = parseNumber(text); if (value !== undefined) return value; if (!host.interactive) throw new InputError('notNumber', 'хонданиРақам', text.trim()); host.write(`${(0, catalog_1.renderMessage)((0, catalog_1.message)('INPUT_ASK_AGAIN', { text: text.trim() }), language)}\n`); } }, }; } }, {"../diagnostics/catalog":"diagnostics/catalog.js"}, ], "runtime/report.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.runtimeDiagnostic = runtimeDiagnostic; /** * An error of a running program as a diagnostic for learners: what happened * (src/runtime/errors.ts), under which name of which line of the `.som` * source, and a hint. Used by `somon run` (src/runtime/node-errors.ts) and by * the playground; no Node.js API is used. */ const catalog_1 = require("../diagnostics/catalog"); const text_1 = require("../diagnostics/text"); const errors_1 = require("./errors"); /** The diagnostic of an explained error, at `place` in `source` when known. */ function runtimeDiagnostic(explained, language, place, source) { const diagnostic = { code: (0, catalog_1.codeOf)(explained.message.id), severity: 'error', message: (0, catalog_1.renderMessage)(explained.message, language), }; const hint = place ? placeDiagnostic(diagnostic, explained, place, source) : explained.hint; if (hint) diagnostic.hint = (0, catalog_1.renderHint)(hint, language); return diagnostic; } /** * Puts `diagnostic` at the place of the error in `source`: under the name the * error is about, when the line is there. Returns the hint for the place. */ function placeDiagnostic(diagnostic, explained, place, source) { const code = source?.split(/\r?\n/)[place.line - 1]; if (code === undefined) { Object.assign(diagnostic, { line: place.line, column: place.column }); return explained.hint; } const column = (0, errors_1.columnOfName)(code, place.column, explained, place.functionName); Object.assign(diagnostic, { line: place.line, column, length: (0, text_1.nameLength)(source, place.line, column), }); if (explained.message.id === 'RUNTIME_READ_OF_NOTHING' && (0, errors_1.readsByIndex)(code, column)) { return (0, catalog_1.message)('INDEX_OUT_OF_RANGE'); } return explained.hint; } }, {"../diagnostics/catalog":"diagnostics/catalog.js","../diagnostics/text":"diagnostics/text.js","./errors":"runtime/errors.js"}, ], "runtime/trace.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.Tracer = exports.TRACE_GLOBAL = void 0; /** * The steps of a program compiled with `trace: true` (src/trace-generator.ts), * for the playground and the lessons to replay: before each statement and at * each test of a condition or loop, the line about to run, the variables the * program sees there with their values, the call depth and how much it has * printed so far. * * The program calls the tracer by the global `__somonTrace` (`TRACE_GLOBAL`): * `names(table)` once, then `step(line, names, getters)`, and `enter(name)` / * `exit()` around the calls of its functions. Each getter reads one variable; * one that throws is a variable whose declaration has not run yet, which is * left out. Values are kept as text, as the program would print them inside * an array (src/runtime/format.ts), with the items of arrays and the fields of * objects for the animations. * * Tracing stops after `maxSteps` steps or `maxBytes` of text: the program goes * on untraced, and the steps so far are what the page replays (`full`). */ const format_1 = require("./format"); /** The global the traced program calls. */ exports.TRACE_GLOBAL = '__somonTrace'; /** Longest text of a value; longer ones end with '…'. */ const MAX_TEXT = 80; /** Longest text of an item of an array or a field of an object. */ const MAX_ITEM_TEXT = 40; const MAX_ITEMS = 20; const MAX_FIELDS = 12; class Tracer { constructor(options) { /** Whether steps are still recorded: the program checks it before each call. */ this.on = true; this.steps = []; /** Recording stopped at a limit. */ this.truncated = false; this.table = []; this.frames = []; this.bytes = 0; this.options = options; this.maxSteps = options.maxSteps ?? 2000; this.maxBytes = options.maxBytes ?? 500000; } /** The names of the getters of each step (`step(line, index, …)` indexes this table). */ names(table) { this.table = table; } step(line, names, getters) { if (!this.on) return; const [outer, ...entry] = this.table[names]; const variables = []; getters.forEach((getter, index) => { let value; try { value = getter(); } catch { // Declared further down: not a variable yet return; } // Functions and classes are what the program does, not what it holds if (typeof value === 'function') return; const variable = describe(entry[index], value); if (index < outer) variable.g = 1; this.bytes += size(variable); variables.push(variable); }); const step = { l: line, d: this.frames.length, v: variables, o: this.options.printed(), }; if (this.frames.length > 0) step.f = this.frames[this.frames.length - 1]; this.steps.push(step); if (this.steps.length >= this.maxSteps || this.bytes >= this.maxBytes) this.stop(); } /** A call of the program's function `name` begins. */ enter(name) { this.frames.push(name); } /** The call that began last ends, by returning or throwing. */ exit() { this.frames.pop(); } /** * The program stopped with an error at `line` (when it is known): the last * step again, marked, with what it had printed by then. */ error(line) { const last = this.steps[this.steps.length - 1]; if (!last || this.truncated) return; this.steps.push({ ...last, l: line ?? last.l, o: this.options.printed(), e: 1 }); } stop() { this.on = false; this.truncated = true; this.options.full?.(); } } exports.Tracer = Tracer; function describe(name, value) { const variable = { n: name, t: kindOf(value), s: text(value, 2, MAX_TEXT) }; if (Array.isArray(value)) { variable.a = value.slice(0, MAX_ITEMS).map(item => text(item, 1, MAX_ITEM_TEXT)); } else if (variable.t === 'object' && isPlainObject(value)) { variable.k = fields(value); } return variable; } function kindOf(value) { if (value === null) return 'null'; if (Array.isArray(value)) return 'array'; switch (typeof value) { case 'number': case 'string': case 'boolean': case 'undefined': return typeof value; case 'object': return 'object'; default: return 'other'; } } function isPlainObject(value) { const prototype = Object.getPrototypeOf(value); return prototype === Object.prototype || prototype === null; } /** The first own fields of an object; a field with a getter is not read. */ function fields(value) { return Object.keys(value) .slice(0, MAX_FIELDS) .map(key => { const descriptor = Object.getOwnPropertyDescriptor(value, key); const shown = 'value' in descriptor ? text(descriptor.value, 1, MAX_ITEM_TEXT) : '…'; return [key, shown]; }); } /** A value as one line of at most `max` characters. */ function text(value, depth, max) { // The line breaks and the indentation around them become one space (a regular // expression would take quadratic time on a long run of spaces) const parts = (0, format_1.inspect)(value, { depth }).split('\n'); const line = parts .map((part, index) => { const start = index > 0 ? part.trimStart() : part; return index < parts.length - 1 ? start.trimEnd() : start; }) .join(' '); return line.length > max ? `${line.slice(0, max - 1)}…` : line; } function size(variable) { let total = variable.n.length + variable.s.length; variable.a?.forEach(item => (total += item.length)); variable.k?.forEach(([key, value]) => (total += key.length + value.length)); return total; } }, {"./format":"runtime/format.js"}, ], "syntactic-conditions.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.skipOuterExpressions = skipOuterExpressions; exports.nullishSemantics = nullishSemantics; exports.truthySemantics = truthySemantics; /** `х чун Т`, `<Т>х`, `х!`, `х бармесоё Т`, `ф<Т>`: TypeScript looks through them. */ const OUTER_EXPRESSIONS = new Set([ 'AsExpression', 'TypeAssertion', 'NonNullExpression', 'SatisfiesExpression', 'InstantiationExpression', ]); /** Expressions whose value may be nullish or not: what calls, members and `ин` give. */ const SOMETIMES_NULLISH = new Set([ 'AwaitExpression', 'CallExpression', 'ChainExpression', 'TaggedTemplateExpression', 'MemberExpression', 'MetaProperty', 'NewExpression', 'YieldExpression', 'ThisExpression', 'ImportExpression', ]); /** Expressions that are objects, so always truthy. */ const ALWAYS_TRUTHY = new Set([ 'ArrayExpression', 'ArrowFunctionExpression', 'ClassExpression', 'FunctionExpression', 'ObjectExpression', 'RegExpLiteral', ]); /** The expression inside `х чун Т`, `<Т>х`, `х!`, `х бармесоё Т` and `ф<Т>`. */ function skipOuterExpressions(expression) { let current = expression; while (OUTER_EXPRESSIONS.has(current.type)) { current = current.expression; } return current; } /** Always if both are, never if both are, sometimes otherwise. */ function either(first, second) { return first === second ? first : 'sometimes'; } /** Whether an expression's value is nullish: the left operand of `??`. */ function nullishSemantics(expression, isUndefined) { const node = skipOuterExpressions(expression); if (SOMETIMES_NULLISH.has(node.type)) return 'sometimes'; switch (node.type) { case 'Identifier': return isUndefined(node) ? 'always' : 'sometimes'; case 'Literal': return node.value === null ? 'always' : 'never'; case 'ConditionalExpression': { const conditional = node; return either(nullishSemantics(conditional.consequent, isUndefined), nullishSemantics(conditional.alternate, isUndefined)); } case 'SequenceExpression': { const { expressions } = node; return nullishSemantics(expressions[expressions.length - 1], isUndefined); } case 'BinaryExpression': case 'AssignmentExpression': return operatorNullishness(node, isUndefined); default: // Literals, objects, functions, templates, other operators return 'never'; } } /** `а || б`, `а && б` may be anything; `а ?? б`, `а = б` are what `б` is; other operators never nullish. */ function operatorNullishness(node, isUndefined) { switch (node.operator) { case '||': case '&&': case '||=': case '&&=': return 'sometimes'; case '??': case '=': case '??=': return nullishSemantics(node.right, isUndefined); default: return 'never'; } } /** Whether a condition's value is truthy. `0`, `1`, `дуруст` and `нодуруст` may be either. */ function truthySemantics(expression, isUndefined) { const node = skipOuterExpressions(expression); if (ALWAYS_TRUTHY.has(node.type)) return 'always'; switch (node.type) { case 'Literal': return literalTruthiness(node); case 'TemplateLiteral': { const template = node; if (template.expressions.length > 0) return 'sometimes'; return template.quasis[0].value.cooked ? 'always' : 'never'; } case 'UnaryExpression': return node.operator === 'void' ? 'never' : 'sometimes'; case 'ConditionalExpression': { const conditional = node; return either(truthySemantics(conditional.consequent, isUndefined), truthySemantics(conditional.alternate, isUndefined)); } case 'Identifier': return isUndefined(node) ? 'never' : 'sometimes'; default: return 'sometimes'; } } function literalTruthiness(literal) { const { value, raw } = literal; if (value === null) return 'never'; if (typeof value === 'string') return value ? 'always' : 'never'; if (typeof value !== 'number') return 'sometimes'; // `агар (1)`, `то (0)` are allowed; BigInt literals (`10n`) and other numbers are not return raw === '0' || raw === '1' ? 'sometimes' : 'always'; } }, {}, ], "tokens.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TokenType = void 0; /* eslint-disable no-unused-vars */ // Token types for lexical analysis var TokenType; (function (TokenType) { // Literals TokenType["NUMBER"] = "NUMBER"; TokenType["STRING"] = "STRING"; TokenType["TEMPLATE_LITERAL"] = "TEMPLATE_LITERAL"; TokenType["TEMPLATE_START"] = "TEMPLATE_START"; TokenType["TEMPLATE_MIDDLE"] = "TEMPLATE_MIDDLE"; TokenType["TEMPLATE_END"] = "TEMPLATE_END"; TokenType["BOOLEAN"] = "BOOLEAN"; TokenType["IDENTIFIER"] = "IDENTIFIER"; TokenType["PRIVATE_NAME"] = "PRIVATE_NAME"; /** Regular expression literal; the value is the source text, `/а+/g`. */ TokenType["REGEX"] = "REGEX"; // Keywords (in Tajik Cyrillic) TokenType["\u0422\u0410\u0492\u0419\u0418\u0420\u0401\u0411\u0410\u041D\u0414\u0410"] = "\u0422\u0410\u0492\u0419\u0418\u0420\u0401\u0411\u0410\u041D\u0414\u0410"; TokenType["\u0421\u041E\u0411\u0418\u0422"] = "\u0421\u041E\u0411\u0418\u0422"; TokenType["\u0424\u0423\u041D\u041A\u0421\u0418\u042F"] = "\u0424\u0423\u041D\u041A\u0421\u0418\u042F"; TokenType["\u0410\u0413\u0410\u0420"] = "\u0410\u0413\u0410\u0420"; TokenType["\u0412\u0410\u0413\u0410\u0420\u041D\u0410"] = "\u0412\u0410\u0413\u0410\u0420\u041D\u0410"; TokenType["\u0427\u0423\u041D\u0418\u041D"] = "\u0427\u0423\u041D\u0418\u041D"; TokenType["\u0411\u0410\u0420\u041E\u0418"] = "\u0411\u0410\u0420\u041E\u0418"; TokenType["\u0422\u041E"] = "\u0422\u041E"; TokenType["\u0411\u041E\u0417\u0413\u0410\u0428\u0422"] = "\u0411\u041E\u0417\u0413\u0410\u0428\u0422"; TokenType["\u0421\u0418\u041D\u0424"] = "\u0421\u0418\u041D\u0424"; TokenType["\u041D\u0410\u0412"] = "\u041D\u0410\u0412"; TokenType["\u0418\u041D"] = "\u0418\u041D"; TokenType["\u0414\u0423\u0420\u0423\u0421\u0422"] = "\u0414\u0423\u0420\u0423\u0421\u0422"; TokenType["\u041D\u041E\u0414\u0423\u0420\u0423\u0421\u0422"] = "\u041D\u041E\u0414\u0423\u0420\u0423\u0421\u0422"; TokenType["\u0425\u041E\u041B\u04E2"] = "\u0425\u041E\u041B\u04E2"; TokenType["\u0411\u0415\u049A\u0418\u041C\u0410\u0422"] = "\u0411\u0415\u049A\u0418\u041C\u0410\u0422"; // Import/Export keywords TokenType["\u0412\u041E\u0420\u0418\u0414"] = "\u0412\u041E\u0420\u0418\u0414"; TokenType["\u0421\u041E\u0414\u0418\u0420"] = "\u0421\u041E\u0414\u0418\u0420"; TokenType["\u0410\u0417"] = "\u0410\u0417"; TokenType["\u0414\u0410\u0420"] = "\u0414\u0410\u0420"; TokenType["\u041F\u0415\u0428\u0424\u0410\u0420\u0417"] = "\u041F\u0415\u0428\u0424\u0410\u0420\u0417"; TokenType["\u0427\u0423\u041D"] = "\u0427\u0423\u041D"; // Built-in functions and objects TokenType["\u0427\u041E\u041F"] = "\u0427\u041E\u041F"; TokenType["\u0421\u0410\u0411\u0422"] = "\u0421\u0410\u0411\u0422"; TokenType["\u0425\u0410\u0422\u041E"] = "\u0425\u0410\u0422\u041E"; TokenType["\u041E\u0413\u041E\u04B2\u04E2"] = "\u041E\u0413\u041E\u04B2\u04E2"; TokenType["\u041C\u0410\u042A\u041B\u0423\u041C\u041E\u0422"] = "\u041C\u0410\u042A\u041B\u0423\u041C\u041E\u0422"; TokenType["\u0418\u0421\u0424\u0422\u0418"] = "\u0418\u0421\u0424\u0422\u0418"; TokenType["\u0422\u0410\u0421\u0414\u0418\u049A"] = "\u0422\u0410\u0421\u0414\u0418\u049A"; TokenType["\u049A\u0410\u0419\u0414"] = "\u049A\u0410\u0419\u0414"; TokenType["\u049A\u0410\u0419\u0414\u0410\u0421\u041B"] = "\u049A\u0410\u0419\u0414\u0410\u0421\u041B"; TokenType["\u0412\u0410\u049A\u0422"] = "\u0412\u0410\u049A\u0422"; TokenType["\u0412\u0410\u049A\u0422\u0421\u0410\u0411\u0422"] = "\u0412\u0410\u049A\u0422\u0421\u0410\u0411\u0422"; TokenType["\u0412\u0410\u049A\u0422\u041E\u0425\u0418\u0420"] = "\u0412\u0410\u049A\u0422\u041E\u0425\u0418\u0420"; TokenType["\u04B6\u0410\u0414\u0412\u0410\u041B"] = "\u04B6\u0410\u0414\u0412\u0410\u041B"; TokenType["\u0424\u0415\u04B2\u0420\u0418\u0421\u0422"] = "\u0424\u0415\u04B2\u0420\u0418\u0421\u0422"; TokenType["XML\u0424\u0415\u04B2\u0420\u0418\u0421\u0422"] = "XML\u0424\u0415\u04B2\u0420\u0418\u0421\u0422"; TokenType["\u041F\u0410\u0419\u04B6\u041E"] = "\u041F\u0410\u0419\u04B6\u041E"; TokenType["\u041F\u041E\u041B\u0418\u0417"] = "\u041F\u041E\u041B\u0418\u0417"; TokenType["\u0413\u0423\u0420\u0423\u04B2"] = "\u0413\u0423\u0420\u0423\u04B2"; TokenType["\u0413\u0423\u0420\u0423\u04B2\u041E\u0425\u0418\u0420"] = "\u0413\u0423\u0420\u0423\u04B2\u041E\u0425\u0418\u0420"; TokenType["\u0413\u0423\u0420\u0423\u04B2\u041F\u04EE\u0428\u0418\u0414\u0410"] = "\u0413\u0423\u0420\u0423\u04B2\u041F\u04EE\u0428\u0418\u0414\u0410"; // Array methods TokenType["\u0420\u04EE\u0419\u0425\u0410\u0422"] = "\u0420\u04EE\u0419\u0425\u0410\u0422"; TokenType["\u0418\u041B\u041E\u0412\u0410"] = "\u0418\u041B\u041E\u0412\u0410"; TokenType["\u0411\u0410\u0420\u041E\u0412\u0410\u0420\u0414\u0410\u041D"] = "\u0411\u0410\u0420\u041E\u0412\u0410\u0420\u0414\u0410\u041D"; TokenType["\u0414\u0410\u0420\u041E\u0417\u04E2"] = "\u0414\u0410\u0420\u041E\u0417\u04E2"; TokenType["\u0425\u0410\u0420\u0418\u0422\u0410"] = "\u0425\u0410\u0420\u0418\u0422\u0410"; TokenType["\u0424\u0418\u041B\u0422\u0420"] = "\u0424\u0418\u041B\u0422\u0420"; TokenType["\u041A\u041E\u0424\u0422\u0410\u041D"] = "\u041A\u041E\u0424\u0422\u0410\u041D"; // String methods TokenType["\u0421\u0410\u0422\u0420\u041C\u0415\u0422\u041E\u0414\u04B2\u041E"] = "\u0421\u0410\u0422\u0420\u041C\u0415\u0422\u041E\u0414\u04B2\u041E"; TokenType["\u0414\u0410\u0420\u041E\u0417\u0418\u0418\u0421\u0410\u0422\u0420"] = "\u0414\u0410\u0420\u041E\u0417\u0418\u0418\u0421\u0410\u0422\u0420"; TokenType["\u041F\u0410\u0419\u0412\u0410\u0421\u0422\u0410\u041D"] = "\u041F\u0410\u0419\u0412\u0410\u0421\u0422\u0410\u041D"; TokenType["\u04B6\u041E\u0419\u0418\u0412\u0410\u0417\u041A\u0423\u041D\u04E2"] = "\u04B6\u041E\u0419\u0418\u0412\u0410\u0417\u041A\u0423\u041D\u04E2"; TokenType["\u04B6\u0423\u0414\u041E\u041A\u0423\u041D\u04E2"] = "\u04B6\u0423\u0414\u041E\u041A\u0423\u041D\u04E2"; // Object methods TokenType["\u041A\u0410\u041B\u0418\u0414\u04B2\u041E"] = "\u041A\u0410\u041B\u0418\u0414\u04B2\u041E"; TokenType["\u049A\u0418\u041C\u0410\u0422\u04B2\u041E"] = "\u049A\u0418\u041C\u0410\u0422\u04B2\u041E"; // Math functions TokenType["\u041C\u0410\u0422\u0415\u041C\u0410\u0422\u0418\u041A\u0410"] = "\u041C\u0410\u0422\u0415\u041C\u0410\u0422\u0418\u041A\u0410"; TokenType["\u04B6\u0410\u041C\u042A"] = "\u04B6\u0410\u041C\u042A"; TokenType["\u0422\u0410\u0420\u04B2"] = "\u0422\u0410\u0420\u04B2"; TokenType["\u0417\u0410\u0420\u0411"] = "\u0417\u0410\u0420\u0411"; TokenType["\u0422\u0410\u049A\u0421\u0418\u041C"] = "\u0422\u0410\u049A\u0421\u0418\u041C"; // Control flow additions TokenType["\u0428\u0418\u041A\u0410\u0421\u0422\u0410\u041D"] = "\u0428\u0418\u041A\u0410\u0421\u0422\u0410\u041D"; TokenType["\u0414\u0410\u0412\u041E\u041C"] = "\u0414\u0410\u0412\u041E\u041C"; TokenType["\u0418\u041D\u0422\u0418\u0425\u041E\u0411"] = "\u0418\u041D\u0422\u0418\u0425\u041E\u0411"; TokenType["\u04B2\u041E\u041B\u0410\u0422"] = "\u04B2\u041E\u041B\u0410\u0422"; TokenType["\u041A\u04EE\u0428\u0418\u0428"] = "\u041A\u04EE\u0428\u0418\u0428"; TokenType["\u0413\u0418\u0420\u0418\u0424\u0422\u0410\u041D"] = "\u0413\u0418\u0420\u0418\u0424\u0422\u0410\u041D"; TokenType["\u041D\u0418\u04B2\u041E\u042F\u0422"] = "\u041D\u0418\u04B2\u041E\u042F\u0422"; TokenType["\u041F\u0410\u0420\u0422\u041E\u0424\u0422\u0410\u041D"] = "\u041F\u0410\u0420\u0422\u041E\u0424\u0422\u0410\u041D"; // Async keywords TokenType["\u04B2\u0410\u041C\u0417\u0410\u041C\u041E\u041D"] = "\u04B2\u0410\u041C\u0417\u0410\u041C\u041E\u041D"; TokenType["\u0418\u041D\u0422\u0418\u0417\u041E\u0420"] = "\u0418\u041D\u0422\u0418\u0417\u041E\u0420"; TokenType["\u0412\u0410\u042A\u0414\u0410"] = "\u0412\u0410\u042A\u0414\u0410"; // Type system keywords (Primitive Types) TokenType["\u0421\u0410\u0422\u0420"] = "\u0421\u0410\u0422\u0420"; TokenType["\u0420\u0410\u049A\u0410\u041C"] = "\u0420\u0410\u049A\u0410\u041C"; TokenType["\u041C\u0410\u041D\u0422\u0418\u049A\u04E2"] = "\u041C\u0410\u041D\u0422\u0418\u049A\u04E2"; TokenType["\u041A\u0410\u041B\u041E\u041D\u0420\u0410\u049A\u0410\u041C"] = "\u041A\u0410\u041B\u041E\u041D\u0420\u0410\u049A\u0410\u041C"; TokenType["\u0420\u0410\u041C\u0417"] = "\u0420\u0410\u041C\u0417"; // Special Types TokenType["\u04B2\u0410\u0420"] = "\u04B2\u0410\u0420"; TokenType["\u041D\u041E\u0428\u0418\u041D\u041E\u0421"] = "\u041D\u041E\u0428\u0418\u041D\u041E\u0421"; TokenType["\u0410\u0411\u0410\u0414\u0410\u041D"] = "\u0410\u0411\u0410\u0414\u0410\u041D"; TokenType["\u0411\u0415\u0414\u0416\u0410\u0412\u041E\u0411"] = "\u0411\u0415\u0414\u0416\u0410\u0412\u041E\u0411"; TokenType["\u041E\u0411\u042A\u0415\u041A\u0422"] = "\u041E\u0411\u042A\u0415\u041A\u0422"; // Type System Keywords TokenType["\u0418\u041D\u0422\u0415\u0420\u0424\u0415\u0419\u0421"] = "\u0418\u041D\u0422\u0415\u0420\u0424\u0415\u0419\u0421"; TokenType["\u041D\u0410\u0412\u042A"] = "\u041D\u0410\u0412\u042A"; TokenType["\u042F\u041A\u0425\u0415\u041B\u0410"] = "\u042F\u041A\u0425\u0415\u041B\u0410"; TokenType["\u041C\u0415\u0420\u041E\u0421"] = "\u041C\u0415\u0420\u041E\u0421"; TokenType["\u0422\u0410\u0422\u0411\u0418\u049A"] = "\u0422\u0410\u0422\u0411\u0418\u049A"; TokenType["\u0421\u0423\u041F\u0415\u0420"] = "\u0421\u0423\u041F\u0415\u0420"; TokenType["\u041A\u041E\u041D\u0421\u0422\u0420\u0423\u041A\u0422\u041E\u0420"] = "\u041A\u041E\u041D\u0421\u0422\u0420\u0423\u041A\u0422\u041E\u0420"; TokenType["\u0425\u041E\u0421\u0423\u0421\u04E2"] = "\u0425\u041E\u0421\u0423\u0421\u04E2"; TokenType["\u041C\u0423\u04B2\u041E\u0424\u0418\u0417\u0410\u0422\u0428\u0423\u0414\u0410"] = "\u041C\u0423\u04B2\u041E\u0424\u0418\u0417\u0410\u0422\u0428\u0423\u0414\u0410"; TokenType["\u04B6\u0410\u041C\u042A\u0418\u042F\u0422\u04E2"] = "\u04B6\u0410\u041C\u042A\u0418\u042F\u0422\u04E2"; TokenType["\u0421\u0422\u0410\u0422\u0418\u041A\u04E2"] = "\u0421\u0422\u0410\u0422\u0418\u041A\u04E2"; TokenType["\u041C\u0410\u0412\u04B2\u0423\u041C"] = "\u041C\u0410\u0412\u04B2\u0423\u041C"; TokenType["\u041D\u041E\u041C\u0424\u0410\u0417\u041E"] = "\u041D\u041E\u041C\u0424\u0410\u0417\u041E"; TokenType["\u041A\u0410\u041B\u0418\u0414\u04B2\u041E\u0418"] = "\u041A\u0410\u041B\u0418\u0414\u04B2\u041E\u0418"; TokenType["\u0418\u041D\u0424\u0415\u0420"] = "\u0418\u041D\u0424\u0415\u0420"; TokenType["\u0425\u0423\u041B\u041E\u0421\u0410"] = "\u0425\u0423\u041B\u041E\u0421\u0410"; TokenType["\u0422\u0410\u041D\u04B2\u041E\u0425\u041E\u041D\u04E2"] = "\u0422\u0410\u041D\u04B2\u041E\u0425\u041E\u041D\u04E2"; TokenType["\u0411\u0415\u041D\u0410\u0417\u0418\u0420"] = "\u0411\u0415\u041D\u0410\u0417\u0418\u0420"; TokenType["\u041D\u0410\u0412\u042A\u0418"] = "\u041D\u0410\u0412\u042A\u0418"; TokenType["\u0410\u0421\u0422"] = "\u0410\u0421\u0422"; TokenType["\u0411\u0410\u0420\u041C\u0415\u0421\u041E\u0401"] = "\u0411\u0410\u0420\u041C\u0415\u0421\u041E\u0401"; // Utility Type Keywords TokenType["\u049A\u0418\u0421\u041C\u04E2"] = "\u049A\u0418\u0421\u041C\u04E2"; TokenType["\u04B2\u0410\u0422\u041C\u04E2"] = "\u04B2\u0410\u0422\u041C\u04E2"; TokenType["\u0422\u0410\u041D\u04B2\u041E\u0425\u041E\u041D"] = "\u0422\u0410\u041D\u04B2\u041E\u0425\u041E\u041D"; TokenType["\u0421\u0410\u0411\u0422_\u041D\u0410\u0412\u042A"] = "\u0421\u0410\u0411\u0422_\u041D\u0410\u0412\u042A"; TokenType["\u0413\u0418\u0420\u0418\u0424\u0422\u0410\u041D_\u041D\u0410\u0412\u042A"] = "\u0413\u0418\u0420\u0418\u0424\u0422\u0410\u041D_\u041D\u0410\u0412\u042A"; TokenType["\u04B2\u0410\u0417\u0424"] = "\u04B2\u0410\u0417\u0424"; TokenType["\u0425\u041E\u0420\u0418\u04B6"] = "\u0425\u041E\u0420\u0418\u04B6"; TokenType["\u0418\u0421\u0422\u0418\u0425\u0420\u041E\u04B6"] = "\u0418\u0421\u0422\u0418\u0425\u0420\u041E\u04B6"; TokenType["\u0411\u0415\u041D\u0410\u041B\u0418\u04E2"] = "\u0411\u0415\u041D\u0410\u041B\u0418\u04E2"; TokenType["\u041D\u0410\u0412\u042A\u0418_\u0411\u041E\u0417\u0413\u0410\u0428\u0422"] = "\u041D\u0410\u0412\u042A\u0418_\u0411\u041E\u0417\u0413\u0410\u0428\u0422"; TokenType["\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u04B2\u041E"] = "\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u04B2\u041E"; TokenType["\u041D\u0410\u0412\u042A\u0418_\u041D\u0410\u041C\u0423\u041D\u0410"] = "\u041D\u0410\u0412\u042A\u0418_\u041D\u0410\u041C\u0423\u041D\u0410"; TokenType["\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u04B2\u041E\u0418_\u041A\u041E\u041D\u0421\u0422\u0420\u0423\u041A\u0422\u041E\u0420"] = "\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u04B2\u041E\u0418_\u041A\u041E\u041D\u0421\u0422\u0420\u0423\u041A\u0422\u041E\u0420"; TokenType["\u041D\u0410\u0412\u042A\u0418_\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u0418_\u0418\u041D"] = "\u041D\u0410\u0412\u042A\u0418_\u041F\u0410\u0420\u0410\u041C\u0415\u0422\u0420\u0418_\u0418\u041D"; TokenType["\u0418\u041D\u0422\u0418\u0417\u041E\u0420\u0428\u0423\u0414\u0410"] = "\u0418\u041D\u0422\u0418\u0417\u041E\u0420\u0428\u0423\u0414\u0410"; // Operators TokenType["PLUS"] = "+"; TokenType["MINUS"] = "-"; TokenType["INCREMENT"] = "++"; TokenType["DECREMENT"] = "--"; TokenType["MULTIPLY"] = "*"; TokenType["DIVIDE"] = "/"; TokenType["MODULO"] = "%"; TokenType["EXPONENT"] = "**"; TokenType["ASSIGN"] = "="; TokenType["PLUS_ASSIGN"] = "+="; TokenType["MINUS_ASSIGN"] = "-="; TokenType["MULTIPLY_ASSIGN"] = "*="; TokenType["DIVIDE_ASSIGN"] = "/="; TokenType["MODULO_ASSIGN"] = "%="; TokenType["EXPONENT_ASSIGN"] = "**="; TokenType["ARROW"] = "=>"; TokenType["EQUAL"] = "=="; TokenType["STRICT_EQUAL"] = "==="; TokenType["NOT_EQUAL"] = "!="; TokenType["STRICT_NOT_EQUAL"] = "!=="; TokenType["LESS_THAN"] = "<"; TokenType["GREATER_THAN"] = ">"; TokenType["LESS_EQUAL"] = "<="; TokenType["GREATER_EQUAL"] = ">="; TokenType["AND"] = "&&"; TokenType["OR"] = "||"; TokenType["AND_ASSIGN"] = "&&="; TokenType["OR_ASSIGN"] = "||="; TokenType["NULLISH_COALESCING"] = "??"; TokenType["NULLISH_ASSIGN"] = "??="; TokenType["BITWISE_AND"] = "&"; TokenType["BITWISE_OR"] = "|"; TokenType["BITWISE_XOR"] = "^"; TokenType["BITWISE_NOT"] = "~"; TokenType["BITWISE_AND_ASSIGN"] = "&="; TokenType["BITWISE_OR_ASSIGN"] = "|="; TokenType["BITWISE_XOR_ASSIGN"] = "^="; TokenType["LEFT_SHIFT"] = "<<"; TokenType["RIGHT_SHIFT"] = ">>"; TokenType["UNSIGNED_RIGHT_SHIFT"] = ">>>"; TokenType["LEFT_SHIFT_ASSIGN"] = "<<="; TokenType["RIGHT_SHIFT_ASSIGN"] = ">>="; TokenType["UNSIGNED_RIGHT_SHIFT_ASSIGN"] = ">>>="; TokenType["NOT"] = "!"; TokenType["SPREAD"] = "..."; TokenType["OPTIONAL_CHAINING"] = "?."; /** `@`, which starts a decorator: `@ном`, `@ном(…)`. */ TokenType["AT"] = "@"; // Punctuation TokenType["SEMICOLON"] = ";"; TokenType["COMMA"] = ","; TokenType["DOT"] = "."; TokenType["COLON"] = ":"; TokenType["QUESTION"] = "?"; // Brackets TokenType["LEFT_PAREN"] = "("; TokenType["RIGHT_PAREN"] = ")"; TokenType["LEFT_BRACE"] = "{"; TokenType["RIGHT_BRACE"] = "}"; TokenType["LEFT_BRACKET"] = "["; TokenType["RIGHT_BRACKET"] = "]"; // Special /** `#!/usr/bin/env node` on the first line; the value is the whole line. */ TokenType["SHEBANG"] = "SHEBANG"; TokenType["EOF"] = "EOF"; TokenType["NEWLINE"] = "NEWLINE"; TokenType["WHITESPACE"] = "WHITESPACE"; /** A line or block comment; only a Lexer created with `{ comments: true }` emits these. */ TokenType["COMMENT"] = "COMMENT"; })(TokenType || (exports.TokenType = TokenType = {})); }, {}, ], "trace-generator.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TraceGenerator = void 0; /** * The code generator of `compile(source, { trace: true })`: the generated * program records the steps it takes (src/runtime/trace.ts), for the * playground and the lessons to replay them line by line. * * Before each statement of a program, block or `ҳолат` arm, and at each test * of `агар`, `то`, `кун … то` and `барои`, it calls * * __somonTrace.on && __somonTrace.step(line, names, [() => а, () => б]) * * with a getter for each variable in scope: the tracer reads them itself, so * the program does what it did untraced. `names` indexes the table of names * the program gives the tracer first. The calls of functions are wrapped in * `enter(name)` and `exit()`, for the call depth. None of this has a position * marker: the mappings and the lines of runtime errors stay the statements'. * * Not traced: expression bodies of arrow functions (`х => х * 2`), and the * depth of `ҳамзамон` functions and generators, whose bodies run in parts. */ const codegen_1 = require("./codegen"); const trace_1 = require("./runtime/trace"); /** Statements whose step is taken elsewhere, or that run nothing a learner would step through. */ const NOT_STEPPED = new Set([ // Their test records the step, each time it is checked 'IfStatement', 'WhileStatement', // Declarations run before the code around them does 'FunctionDeclaration', 'ClassDeclaration', // Their statements have steps of their own 'BlockStatement', 'EmptyStatement', // Types: comments in the code 'InterfaceDeclaration', 'TypeAlias', ]); class TraceGenerator extends codegen_1.CodeGenerator { constructor() { super(...arguments); /** The names of the steps' getters (see `Tracer.names`), and the index of each list. */ this.nameTable = []; this.nameIndex = new Map(); /** For each function around the current node: the number of scopes outside it. */ this.functionStarts = []; } programPrologue() { return [`${trace_1.TRACE_GLOBAL}.names([${this.nameTable.join(', ')}]);`]; } /** The last step: the top level has run, with the variables it ends with. */ programEpilogue() { return [this.indent(`${this.stepCall(0)};`)]; } generateStatements(statements) { const generated = []; for (const stmt of statements) { const code = this.generateStatement(stmt); if (code.length === 0) continue; if (TraceGenerator.isStepped(stmt)) generated.push(this.indent(`${this.stepCall(stmt.line)};`)); generated.push(code); } return generated; } generateTest(test, code) { return `(${this.stepCall(test.line)}, ${code})`; } generateFunctionParts(params, body, isAsync = false, thisType, info = {}) { this.functionStarts.push(this.scopes.length); try { const parts = super.generateFunctionParts(params, body, isAsync, thisType, info); // An async function or a generator returns before its body has run to its end if (isAsync || info.generator) return parts; const enter = `${trace_1.TRACE_GLOBAL}.enter(${JSON.stringify(info.name ?? '')});`; return { params: parts.params, body: `{ ${enter} try ${parts.body} finally { ${trace_1.TRACE_GLOBAL}.exit(); } }`, }; } finally { this.functionStarts.pop(); } } /** * A statement gets a step of its own unless its test records it, or it * declares a function or class. A `барои` without a test (`барои (;;)`) * gets one; a label gets the step of the statement it labels. */ static isStepped(stmt) { let target = stmt; while (target.type === 'LabeledStatement') target = target.body; if (target.type === 'ForStatement') return !target.test; return !NOT_STEPPED.has(target.type); } /** `__somonTrace.on && __somonTrace.step(line, names, getters)` for the variables in scope. */ stepCall(line) { const { names, outer } = this.visibleNames(); const getters = names.map(name => `() => ${name}`).join(', '); const index = this.namesIndex([outer, ...names]); return `${trace_1.TRACE_GLOBAL}.on && ${trace_1.TRACE_GLOBAL}.step(${line}, ${index}, [${getters}])`; } /** * The names in scope, outer ones first, each once (an inner declaration * shadows an outer one); `outer` of them are declared outside the current * function. Functions and classes are among them: the tracer leaves out * values that are functions. */ visibleNames() { const start = this.functionStarts.length > 0 ? this.functionStarts[this.functionStarts.length - 1] : 0; const seen = new Set(); const own = []; const outside = []; for (let depth = this.scopes.length - 1; depth >= 0; depth--) { for (const name of [...this.scopes[depth]].reverse()) { if (seen.has(name)) continue; seen.add(name); (depth >= start ? own : outside).push(name); } } outside.reverse(); own.reverse(); return { names: [...outside, ...own], outer: outside.length }; } namesIndex(entry) { const key = JSON.stringify(entry); let index = this.nameIndex.get(key); if (index === undefined) { index = this.nameTable.length; this.nameTable.push(key); this.nameIndex.set(key, index); } return index; } } exports.TraceGenerator = TraceGenerator; }, {"./codegen":"codegen.js","./runtime/trace":"runtime/trace.js"}, ], "type-checker.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.TypeChecker = exports.BUILTIN_MEMBERS = exports.TypeCheckErrorCode = void 0; const builtin_globals_1 = require("./builtin-globals"); const builtin_names_1 = require("./builtin-names"); const catalog_1 = require("./diagnostics/catalog"); const suggest_1 = require("./diagnostics/suggest"); const syntactic_conditions_1 = require("./syntactic-conditions"); const type_names_1 = require("./type-names"); /** * Stable error codes for type checking diagnostics */ exports.TypeCheckErrorCode = { TypeMismatch: 'TYPE_NOT_ASSIGNABLE', ClassNotFound: 'CLASS_NOT_FOUND', InvalidExtends: 'INVALID_EXTENDS', CircularInheritance: 'CIRCULAR_INHERITANCE', UndefinedIdentifier: 'UNDEFINED_IDENTIFIER', ArgumentCountMismatch: 'ARGUMENT_COUNT_MISMATCH', ArgumentTypeMismatch: 'ARGUMENT_TYPE_MISMATCH', PropertyNotFound: 'PROPERTY_NOT_FOUND', PossiblyNull: 'POSSIBLY_NULL', ReadonlyAssignment: 'READONLY_ASSIGNMENT', UsedBeforeInitialization: 'USED_BEFORE_INITIALIZATION', NoMatchingOverload: 'NO_MATCHING_OVERLOAD', InvalidOverride: 'INVALID_OVERRIDE', TypeOnlyImportValue: 'TYPE_ONLY_IMPORT_VALUE', AbstractInstantiation: 'ABSTRACT_INSTANTIATION', /** A condition or `??` operand its syntax decides (TypeScript 5.6: TS2869, TS2871 to TS2873). */ ConstantCondition: 'CONSTANT_CONDITION', /** A call of a value that is not a function: `математика(1)`. */ NotCallable: 'NOT_CALLABLE', /** A new value for a `собит`: `собит х = 1; х = 2;` (TypeScript's TS2588). */ ConstAssignment: 'CONST_ASSIGNMENT', /** `агар (х = 1)`: a condition that assigns, where a comparison was meant. */ AssignmentInCondition: 'ASSIGNMENT_IN_CONDITION', /** A type name that is neither built in nor declared: `тағ а: мантики`. */ TypeNotFound: 'TYPE_NOT_FOUND', }; /** * Interfaces that `эълон глобалӣ { интерфейс Array<Т> { … } }` may extend, by * the built-in values they describe (see `augmentedMember`). */ const AUGMENTABLE_BUILTINS = new Set([ 'Array', 'ReadonlyArray', 'String', 'Number', 'Boolean', 'Object', 'Map', 'Set', 'Promise', 'RegExp', ]); const UNKNOWN = { kind: 'unknown' }; const NULL_TYPE = { kind: 'primitive', name: 'null' }; const UNDEFINED_TYPE = { kind: 'primitive', name: 'undefined' }; const NUMBER_TYPE = { kind: 'primitive', name: 'number' }; const STRING_TYPE = { kind: 'primitive', name: 'string' }; /** `хондан(савол?)` and `хонданиРақам(савол?)`: the input functions of the run time. */ const INPUT_FUNCTION_TYPES = new Map([ ['хондан', STRING_TYPE], ['хонданиРақам', NUMBER_TYPE], ].map(([name, returnType]) => [ name, { kind: 'function', name, paramTypes: [{ kind: 'primitive', name: 'any' }], paramNames: ['савол'], paramOptional: [true], returnType, }, ])); const BOOLEAN_TYPE = { kind: 'primitive', name: 'boolean' }; const VOID_TYPE = { kind: 'primitive', name: 'void' }; /** `ин` as a type; bound to the receiver's type where a member is used. */ const THIS_TYPE = { kind: 'this' }; /** Array methods a `танҳохонӣ` (readonly) array doesn't have. */ const MUTATING_ARRAY_METHODS = new Set([ 'push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse', 'fill', 'copyWithin', ]); /** Every property name readable on values with the given prototype. */ function prototypeMembers(prototype) { const names = new Set(); for (let p = prototype; p; p = Object.getPrototypeOf(p)) { Object.getOwnPropertyNames(p).forEach(name => names.add(name)); } return names; } /** * Members of built-in types, taken from the running JavaScript engine so the * lists match what the compiled program can call. */ exports.BUILTIN_MEMBERS = { object: prototypeMembers(Object.prototype), array: prototypeMembers(Array.prototype), string: prototypeMembers(String.prototype), number: prototypeMembers(Number.prototype), boolean: prototypeMembers(Boolean.prototype), function: prototypeMembers(Function.prototype), Map: prototypeMembers(Map.prototype), Set: prototypeMembers(Set.prototype), Promise: prototypeMembers(Promise.prototype), // An instance, for its own `lastIndex` RegExp: prototypeMembers(/(?:)/), }; /** Type of regular expression literals (`/а+/g`) and `нав RegExp(…)`. */ const REGEXP_TYPE = { kind: 'generic', name: 'RegExp', typeParameters: [] }; /** Array methods that return an element or `undefined` when there is none. */ const ARRAY_ELEMENT_OR_UNDEFINED = new Set([ 'pop', 'shift', 'at', 'find', 'findLast', ]); const RELATIONAL_OPERATORS = new Set(['<', '>', '<=', '>=']); /** Expressions that only assert a type (`х чун Т`, `<Т>х`, `х бармесоё Т`, `х!`). */ const ASSERTION_TYPES = new Set([ 'AsExpression', 'TypeAssertion', 'SatisfiesExpression', 'NonNullExpression', ]); /** Statements an unlabelled `шикастан` leaves. */ const JUMP_TARGETS = new Set([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement', 'SwitchStatement', ]); /** Key the parser gives index signatures (`[калид: сатр]: Т`) in interface bodies. */ const INDEX_SIGNATURE_KEY = '__computed__'; /** Spellings of the Promise type; `Ваъда` is the Tajik alias of `Promise`. */ const PROMISE_NAMES = new Set(['Promise', 'Ваъда', 'ваъда', 'ВАЪДА']); const NUMERIC_BINARY_OPERATORS = new Set([ '-', '*', '/', '%', '**', '<<', '>>', '>>>', '&', '|', '^', ]); const BOOLEAN_BINARY_OPERATORS = new Set([ '==', '!=', '===', '!==', '<', '>', '<=', '>=', 'in', 'instanceof', ]); /** * Type checker for SomonScript AST * Provides comprehensive type checking with Tajik Cyrillic type annotations */ class TypeChecker { constructor(source, options = {}) { this.errors = []; this.warnings = []; /** Lexical scope chain; index 0 is the global scope. */ this.scopes = []; /** Unique id of each scope in `scopes`, so narrowing facts survive shadowing. */ this.scopeIds = []; this.nextScopeId = 0; /** Reference keys of `собит` bindings; their narrowing carries into closures. */ this.constKeys = new Set(); /** Names assigned anywhere after their declaration (`х = …`, `х++`, …). */ this.reassignedNames = new Set(); /** Narrowed types of references at the current point (see `referenceKey`). */ this.narrowed = new Map(); /** While positive, diagnostics are dropped (expressions re-inferred for narrowing). */ this.silent = 0; this.interfaceTable = new Map(); this.typeAliasTable = new Map(); this.functionStack = []; /** Type parameter names in scope (`<Т>` of functions, classes, …), innermost last. */ this.typeParameterScopes = []; /** Classes whose body is being checked, innermost last (the owners of `#ном` names). */ this.classStack = []; /** Enum declarations already declared (merged enums add to the first one's type). */ this.declaredEnums = new WeakSet(); /** The names the program declares that may be types (`declaredTypeNames`). */ this.declaredTypes = new Set(); /** Type names already reported as unknown, by their node. */ this.reportedTypeNames = new WeakSet(); /** Members of the declarations of a (merged) enum checked so far, by its enum object. */ this.checkedEnumMembers = new WeakMap(); /** Types `initializePrimitiveTypes` gives the names `сатр`, `рақам`, … as values. */ this.primitiveValues = new Set(); /** Callee type of each call when last inferred, for type predicates (`х аст Т`). */ this.calleeTypes = new WeakMap(); /** * Reference keys of bindings that hold a class made by a class expression * (`собит К = синф {…}`): `К.ном` reads a static member, as for `синф К`. */ this.classValueKeys = new Set(); /** (source, target) pairs being compared, to stop recursion on recursive types. */ this.assignabilityStack = []; /** `эълон модул "ном" { … }`: what each declared module exports, by name. */ this.ambientModules = new Map(); /** * Members `эълон глобалӣ { интерфейс Array<Т> { … } }` adds to built-in * types, by interface name. */ this.builtinAugmentations = new Map(); this.sourceLines = []; this.statementHandlers = { VariableDeclaration: s => this.checkVariableDeclaration(s), VariableDeclarationList: s => s.declarations.forEach(d => this.checkVariableDeclaration(d)), FunctionDeclaration: s => this.checkFunctionDeclaration(s), ClassDeclaration: s => this.checkClassDeclaration(s), ExpressionStatement: s => this.checkExpressionStatement(s), ExportDeclaration: s => { const inner = s.declaration; if (inner) this.checkStatement(inner); }, BlockStatement: s => this.withScope(() => this.checkStatements(s.body)), IfStatement: s => this.checkIfStatement(s), WhileStatement: s => this.checkWhileStatement(s), DoWhileStatement: s => this.checkDoWhileStatement(s), LabeledStatement: s => this.checkLabeledStatement(s), EnumDeclaration: s => this.checkEnumDeclaration(s), ForStatement: s => this.checkForStatement(s), ForInStatement: s => this.checkForInOfStatement(s, true), ForOfStatement: s => this.checkForInOfStatement(s, false), SwitchStatement: s => this.checkSwitchStatement(s), TryStatement: s => this.checkTryStatement(s), ThrowStatement: s => this.inferExpressionType(s.argument), ReturnStatement: s => this.checkReturnStatement(s), NamespaceDeclaration: s => this.checkNamespace(s), ExportAssignment: s => this.inferExpressionType(s.expression), ImportEqualsDeclaration: s => this.checkImportEquals(s), }; this.expressionHandlers = { Literal: e => this.inferLiteralType(e), RegExpLiteral: () => REGEXP_TYPE, ClassExpression: e => this.inferClassExpressionType(e), Identifier: e => this.inferIdentifierType(e), ArrayExpression: (e, t) => this.inferArrayExpressionType(e, t), ObjectExpression: (e, t) => this.inferObjectType(e, t), CallExpression: e => this.inferCallType(e), NewExpression: e => this.inferNewExpressionType(e), MemberExpression: e => this.inferMemberType(e), ChainExpression: e => this.inferExpressionType(e.expression), AssignmentExpression: e => this.inferAssignmentType(e), BinaryExpression: e => this.inferBinaryType(e), UnaryExpression: e => this.inferUnaryType(e), UpdateExpression: e => { this.checkConstTarget(e.argument); this.checkReadonlyTarget(e.argument); return this.inferNumericOperand(e.argument); }, TaggedTemplateExpression: e => this.inferTaggedTemplateType(e), TemplateLiteral: e => { e.expressions.forEach(part => this.inferExpressionType(part)); return { kind: 'primitive', name: 'string' }; }, ConditionalExpression: (e, t) => this.inferConditionalType(e, t), SequenceExpression: e => e.expressions.reduce((_, part) => this.inferExpressionType(part), UNKNOWN), SpreadElement: e => { this.inferExpressionType(e.argument); return UNKNOWN; }, AwaitExpression: e => this.unwrapPromise(this.inferExpressionType(e.argument)), // The value of `ҳосил х` is whatever the caller passes to `next()` YieldExpression: e => { const argument = e.argument; if (argument) this.inferExpressionType(argument); return UNKNOWN; }, ArrowFunctionExpression: e => this.inferFunctionExpressionType(e, true), FunctionExpression: e => this.inferFunctionExpressionType(e, false), ThisExpression: () => this.currentFunction()?.thisType ?? UNKNOWN, AsExpression: e => this.inferAssertionType(e), TypeAssertion: e => this.inferAssertionType(e), SatisfiesExpression: e => this.inferSatisfiesType(e), NonNullExpression: e => this.removeNullish(this.inferExpressionType(e.expression)), // `ф<рақам>`: the generic function (or class) itself, as calls of it are checked InstantiationExpression: e => this.inferExpressionType(e.expression), ImportExpression: e => { this.inferExpressionType(e.source); return UNKNOWN; }, }; /** `беқимат` (`undefined`) naming the global value, not a local. */ this.isGlobalUndefined = (identifier) => (identifier.name === 'беқимат' || identifier.name === 'undefined') && !this.lookup(identifier.name); /** Conditions and `??` operands reported by `reportConstantCondition`. */ this.constantConditions = new WeakSet(); this.typePrinters = { primitive: t => this.mapPrimitiveToTajik(t.name), array: t => { const element = this.typeToString(t.elementType); const list = ['union', 'intersection', 'function', 'constructor'].includes(t.elementType.kind) ? `(${element})[]` : `${element}[]`; return t.readonly ? `танҳохонӣ ${list}` : list; }, union: t => this.typeListToString(t), intersection: t => this.typeListToString(t), tuple: t => this.tupleToString(t), this: () => 'ин', constructor: (t) => `нав ${this.functionTypeToString(t)}`, literal: t => (typeof t.value === 'string' ? `"${t.value}"` : String(t.value)), unique: t => `беназир ${this.typeToString(t.baseType)}`, object: t => this.objectTypeToString(t), generic: t => this.genericTypeToString(t), function: t => this.functionTypeToString(t), unknown: t => t.name ?? 'ношинос', }; this.sourceLines = source ? source.split(/\r?\n/) : []; this.strict = Boolean(options.strict); this.onIdentifierType = options.onIdentifierType; this.onBinaryTypes = options.onBinaryTypes; } /** Reports the type of a declared or read name to `onIdentifierType`. */ recordIdentifierType(identifier, type) { if (this.silent === 0) this.onIdentifierType?.(identifier, type); } /** * Initialize primitive types in the symbol table */ initializePrimitiveTypes() { this.primitiveValues = new Set(); for (const [name, primitive] of [ ['сатр', 'string'], ['рақам', 'number'], ['мантиқӣ', 'boolean'], ['холӣ', 'null'], ]) { const type = { kind: 'primitive', name: primitive }; this.primitiveValues.add(type); this.declare(name, type); } } getSnippet(line) { return this.sourceLines[line - 1] ?? ''; } /** * Perform type checking on the entire program * @param program - The AST program to type check * @returns Type checking result with errors and warnings */ check(program) { this.errors = []; this.warnings = []; this.scopes = [new Map()]; this.scopeIds = [this.nextScopeId++]; this.constKeys = new Set(); this.reassignedNames = this.collectReassignedNames(program); this.narrowed = new Map(); this.interfaceTable = new Map(); this.typeAliasTable = new Map(); this.functionStack = []; this.typeParameterScopes = []; this.classStack = []; this.calleeTypes = new WeakMap(); this.classValueKeys = new Set(); this.ambientModules = new Map(); this.builtinAugmentations = new Map(); this.declaredEnums = new WeakSet(); this.declaredTypes = (0, type_names_1.declaredTypeNames)(program); this.reportedTypeNames = new WeakSet(); this.initializePrimitiveTypes(); // `эълон глобалӣ { … }` declares top-level names; `эълон модул "ном"` modules const body = this.expandGlobalDeclarations(program.body); this.collectAmbientModules(body); // First pass: collect type definitions and hoist top-level bindings this.collectTypeDefinitions(body); // Second pass: type check statements this.checkStatements(body); return { errors: this.errors, warnings: this.warnings, }; } // --------------------------------------------------------------------------- // Scopes // --------------------------------------------------------------------------- lookup(name) { const index = this.scopeIndexOf(name); return index === -1 ? undefined : this.scopes[index].get(name); } /** Index in `scopes` of the innermost scope declaring `name`, or -1. */ scopeIndexOf(name) { for (let i = this.scopes.length - 1; i >= 0; i--) { if (this.scopes[i].has(name)) return i; } return -1; } declare(name, type) { this.scopes[this.scopes.length - 1].set(name, type); // A (re)declaration starts with the declared type this.invalidate(this.bindingKey(this.scopes.length - 1, name)); } withScope(body) { this.scopes.push(new Map()); this.scopeIds.push(this.nextScopeId++); try { body(); } finally { this.scopes.pop(); this.scopeIds.pop(); } } currentFunction() { return this.functionStack[this.functionStack.length - 1]; } // --------------------------------------------------------------------------- // Declaration collection and hoisting // --------------------------------------------------------------------------- unwrapExport(statement) { if (statement.type === 'ExportDeclaration') { return statement.declaration ?? statement; } return statement; } /** * Collects the program's interfaces and type aliases. Interfaces and classes * are registered as empty shells first so that declaration order doesn't * matter for references between them. */ collectTypeDefinitions(statements) { const declarations = statements.map(s => this.unwrapExport(s)); // Enum names are types too: `интерфейс И { р: Ранг; }` this.declareEnums(declarations); const interfaces = declarations.filter((s) => s.type === 'InterfaceDeclaration'); for (const interfaceDecl of interfaces) { if (!this.interfaceTable.has(interfaceDecl.name.name)) { this.interfaceTable.set(interfaceDecl.name.name, { kind: 'interface', name: interfaceDecl.name.name, properties: new Map(), }); } } const classes = this.declareClassShells(declarations); for (const statement of declarations) { if (statement.type === 'TypeAlias') this.collectTypeAlias(statement); } const filled = new Set(); for (const interfaceDecl of interfaces) { this.collectInterface(interfaceDecl, interfaces, filled); } classes.forEach(classDecl => this.collectClass(classDecl)); } /** * Hoists the bindings a statement list declares into the current scope: * classes and functions with their full types, variables, namespaces and * imports as placeholders that the statement itself refines when checked. */ hoistDeclarations(statements) { const declarations = statements.map(s => this.unwrapExport(s)); this.declareEnums(declarations); const classes = declarations.filter((s) => s.type === 'ClassDeclaration' && !this.isDeclaredHere(s)); classes.forEach(classDecl => this.declareClassShell(classDecl)); classes.forEach(classDecl => this.collectClass(classDecl)); // Overload signatures (`функсия ф(х: рақам): рақам;`), by function name const signatures = new Map(); for (const statement of declarations) { switch (statement.type) { case 'FunctionDeclaration': this.hoistFunctionDeclaration(statement); break; case 'FunctionSignature': { const signature = statement; const list = signatures.get(signature.name.name) ?? []; list.push(this.buildFunctionType(signature.name.name, signature)); signatures.set(signature.name.name, list); break; } case 'VariableDeclaration': this.hoistVariableDeclaration(statement); break; case 'VariableDeclarationList': statement.declarations.forEach(d => this.hoistVariableDeclaration(d)); break; case 'NamespaceDeclaration': this.hoistNamespace(statement); break; case 'ImportDeclaration': this.collectImport(statement); break; case 'ImportEqualsDeclaration': this.collectImportEquals(statement); break; } } signatures.forEach((overloads, name) => this.declareOverloads(name, overloads)); } /** * Calls of an overloaded function are checked against its overload * signatures; the implementation's own signature is not callable. Without * an implementation (`эълон функсия`) the signatures alone make the function. */ declareOverloads(name, overloads) { const scope = this.scopes[this.scopes.length - 1]; const implementation = scope.get(name); if (implementation?.kind === 'function' && !implementation.overloads) { scope.set(name, { ...implementation, overloads }); } else if (!implementation) { this.declare(name, overloads.length > 1 ? { ...overloads[0], overloads } : overloads[0]); } } /** * A namespace is an open object of its exported members (see * `checkNamespace`); merged with a class, function or enum of its name * (declared before it), it adds to that value instead. */ hoistNamespace(namespace) { const name = namespace.name.name; let target = this.scopes[this.scopes.length - 1].get(name); if (!target) { target = { kind: 'object', name, properties: new Map(), open: true }; this.declare(name, target); } // Members are known by name before the block is checked (and typed after) for (const statement of namespace.body.statements) { if (!namespace.declare && !statement.exported) continue; if (TypeChecker.TYPE_DECLARATIONS.has(statement.type)) continue; for (const member of this.declaredNames(statement)) { this.addNamespaceMember(target, member, UNKNOWN, false); } } } /** A member a namespace adds to its value: a property, or a static member of a class. */ addNamespaceMember(target, name, type, replace) { if (target.kind === 'class') { target.staticMembers?.add(name); } else if (target.kind === 'object' && target.properties) { if (replace || !target.properties.has(name)) { target.properties.set(name, { type, optional: false }); } } } /** * Checks a namespace block in its own scope, where the members other blocks * of the namespace export are known too. What it exports (everything, in an * `эълон номфазо`) becomes a member of the namespace's value. */ checkNamespace(namespace) { const target = this.lookup(namespace.name.name); this.withScope(() => { const statements = namespace.body.statements; if (target?.kind === 'object' && !target.enumType) { // What the other blocks export; this block's own declarations come next const own = new Set(statements.flatMap(statement => this.declaredNames(statement))); target.properties?.forEach((member, name) => { if (!own.has(name)) this.declare(name, member.type); }); } this.checkStatements(statements); if (!target) return; const scope = this.scopes[this.scopes.length - 1]; for (const statement of statements) { if (!namespace.declare && !statement.exported) continue; if (TypeChecker.TYPE_DECLARATIONS.has(statement.type)) continue; for (const name of this.declaredNames(statement)) { this.addNamespaceMember(target, name, scope.get(name) ?? UNKNOWN, true); } } }); } /** `ворид х = Н.а;`: the alias has the type of what it names. */ checkImportEquals(declaration) { if (!declaration.reference || declaration.importKind === 'type') return; this.declare(declaration.id.name, this.inferExpressionType(declaration.reference)); } isDeclaredHere(classDecl) { const existing = this.scopes[this.scopes.length - 1].get(classDecl.name.name); return existing?.kind === 'class' && existing.properties !== undefined; } declareClassShells(declarations) { const classes = declarations.filter((s) => s.type === 'ClassDeclaration'); classes.forEach(classDecl => this.declareClassShell(classDecl)); return classes; } declareClassShell(classDecl) { this.declare(classDecl.name.name, { kind: 'class', name: classDecl.name.name, properties: new Map(), }); } collectImport(importDecl) { // Register imported local names as 'unknown' so references don't trip the // undefined-identifier diagnostic. Cross-module type inference isn't wired, // except for modules declared with `эълон модул "ном" { … }`. const module = this.ambientModules.get(String(importDecl.source.value)); for (const spec of importDecl.specifiers) { const typeOnly = importDecl.importKind === 'type' || spec.importKind === 'type'; if (typeOnly) { // `ворид навъ { Т }`: a type, not a value this.declare(spec.local.name, { kind: 'unknown', name: spec.local.name, typeOnly: true }); } else { const type = module ? this.ambientImportType(module, spec, importDecl) : UNKNOWN; this.declare(spec.local.name, type); } } } /** The type of what one specifier imports from a declared module. */ ambientImportType(module, spec, importDecl) { const exportAssignment = module.values.get('export='); if (spec.type === 'ImportNamespaceSpecifier') { return exportAssignment ?? this.ambientModuleObject(module, String(importDecl.source.value)); } const isDefault = spec.type === 'ImportDefaultSpecifier'; const name = isDefault ? 'default' : spec.imported.name; const type = module.values.get(name) ?? (isDefault ? exportAssignment : undefined) ?? (exportAssignment ? this.getAllProperties(exportAssignment).get(name)?.type : undefined) ?? this.forwardedExport(module, name, new Set()); if (type) return type; if (module.types.has(name) || (exportAssignment && this.isOpenType(exportAssignment))) { return UNKNOWN; } const moduleName = String(importDecl.source.value); const missing = isDefault ? (0, catalog_1.message)('PROPERTY_NOT_FOUND.noDefaultExport', { module: moduleName }) : (0, catalog_1.message)('PROPERTY_NOT_FOUND.noExportedMember', { module: moduleName, name }); this.addError(exports.TypeCheckErrorCode.PropertyNotFound, missing, spec.line, spec.column); return UNKNOWN; } /** * The type of `name` when `module` exports it from another module; unknown * when that module is not declared here, undefined when no module has it. */ forwardedExport(module, name, seen) { if (seen.has(module)) return undefined; seen.add(module); const forwarded = module.forwarded.get(name); if (forwarded) { const source = this.ambientModules.get(forwarded.source); if (!source) return UNKNOWN; if (forwarded.name === '*') return this.ambientModuleObject(source, forwarded.source); return this.exportedFrom(source, forwarded.name, seen) ?? UNKNOWN; } // `содир * аз "н"` leaves out the default export if (name === 'default') return undefined; for (const sourceName of module.forwardedAll) { const source = this.ambientModules.get(sourceName); if (!source) return UNKNOWN; const type = this.exportedFrom(source, name, seen); if (type) return type; } return undefined; } /** What `module` exports as `name`: a value's type, unknown for a type, or undefined. */ exportedFrom(module, name, seen) { if (module.types.has(name)) return UNKNOWN; return module.values.get(name) ?? this.forwardedExport(module, name, seen); } /** `ворид * чун м аз "ном"`: an object of the module's exports. */ ambientModuleObject(module, source) { const properties = new Map(); module.values.forEach((type, name) => properties.set(name, { type, optional: false })); // What it exports from other modules is not listed: other members are not errors const forwards = module.forwarded.size > 0 || module.forwardedAll.length > 0; return { kind: 'object', name: `"${source}"`, properties, ...(forwards && { open: true }) }; } /** `ворид х = require("ном")`, `ворид х = Н.а;` (the alias is typed when checked). */ collectImportEquals(declaration) { const name = declaration.id.name; if (declaration.importKind === 'type') { this.declare(name, { kind: 'unknown', name, typeOnly: true }); return; } const source = declaration.source ? String(declaration.source.value) : ''; const module = this.ambientModules.get(source); const type = module ? (module.values.get('export=') ?? this.ambientModuleObject(module, source)) : UNKNOWN; this.declare(name, type); } /** * `эълон глобалӣ { … }` declares names of the global scope: its body is * checked as top-level statements. Interfaces of built-in types there * (`интерфейс Array<Т> { охирин(): Т; }`) add members to those types. */ expandGlobalDeclarations(statements) { return statements.flatMap(statement => { const global = statement; if (global.type !== 'AmbientModuleDeclaration' || !global.global) return [statement]; return global.body.filter(inner => { const declaration = this.unwrapExport(inner); if (declaration.type !== 'InterfaceDeclaration' || !AUGMENTABLE_BUILTINS.has(declaration.name.name)) { return true; } this.collectBuiltinAugmentation(declaration); return false; }); }); } collectBuiltinAugmentation(declaration) { const name = declaration.name.name; const target = { kind: 'interface', name, properties: this.builtinAugmentations.get(name) ?? new Map(), }; this.withTypeParameters(declaration.typeParameters, () => this.collectPropertySignatures(declaration.body.properties, target)); this.builtinAugmentations.set(name, target.properties); } /** A member that `эълон глобалӣ` adds to a built-in type, by the built-in's kind. */ augmentedMember(type, name, jsName) { if (this.builtinAugmentations.size === 0) return undefined; const owners = ['Object']; if (type.kind === 'array' || type.kind === 'tuple') owners.push('Array', 'ReadonlyArray'); else if (this.isStringType(type)) owners.push('String'); else if (this.isNumericType(type)) owners.push('Number'); else if (type.kind === 'generic' && type.name) owners.push(type.name); else if (this.getBaseType(type).name === 'boolean') owners.push('Boolean'); for (const owner of owners) { const members = this.builtinAugmentations.get(owner); const member = members && this.findProperty(members, name, jsName); if (member) return member; } return undefined; } /** * Collects what each `эълон модул "ном" { … }` exports: everything it * declares, or only what it marks `содир` when it marks anything. */ collectAmbientModules(statements) { for (const statement of statements) { const module = statement; if (module.type !== 'AmbientModuleDeclaration' || !module.name) continue; const exports = { values: new Map(), types: new Set(), forwarded: new Map(), forwardedAll: [], }; const explicit = module.body.some(inner => inner.type === 'ExportDeclaration' || inner.type === 'ExportAssignment'); this.withScope(() => { this.collectTypeDefinitions(module.body); this.hoistDeclarations(module.body); const scope = this.scopes[this.scopes.length - 1]; for (const inner of module.body) { this.collectModuleExports(inner, explicit, scope, exports); } }); this.ambientModules.set(String(module.name.value), exports); } } collectModuleExports(statement, explicit, scope, exports) { if (statement.type === 'ExportAssignment') { exports.values.set('export=', this.quietType(statement.expression)); return; } const exportDecl = statement; if (statement.type === 'ExportDeclaration' && exportDecl.source) { this.collectForwardedExports(exportDecl, exports); return; } if (statement.type === 'ExportDeclaration' && !exportDecl.declaration) { for (const spec of exportDecl.specifiers) { const type = scope.get(spec.local.name); if (type) exports.values.set(spec.exported.name, type); else exports.types.add(spec.exported.name); } return; } if (explicit && statement.type !== 'ExportDeclaration') return; // An import alias is exported only when marked so (TypeScript's TS2459) if (statement.type === 'ImportEqualsDeclaration') return; const declaration = this.unwrapExport(statement); for (const name of this.declaredNames(declaration)) { if (TypeChecker.TYPE_DECLARATIONS.has(declaration.type)) { exports.types.add(name); } else { exports.values.set(exportDecl.default ? 'default' : name, scope.get(name) ?? UNKNOWN); } } } /** `содир { х } аз "н"`, `содир * аз "н"`, `содир * чун Н аз "н"` in a declared module. */ collectForwardedExports(exportDecl, exports) { const source = String(exportDecl.source.value); if (exportDecl.namespaceExport) { exports.forwarded.set(exportDecl.namespaceExport.name, { source, name: '*' }); } else if (exportDecl.specifiers.length === 0) { exports.forwardedAll.push(source); } for (const spec of exportDecl.specifiers) { exports.forwarded.set(spec.exported.name, { source, name: spec.local.name }); } } /** Names a declaration binds (or, for interfaces and type aliases, declares as types). */ declaredNames(statement) { switch (statement.type) { case 'VariableDeclaration': return TypeChecker.patternNames(statement.identifier); case 'VariableDeclarationList': return statement.declarations.flatMap(d => this.declaredNames(d)); case 'FunctionDeclaration': case 'FunctionSignature': case 'ClassDeclaration': case 'EnumDeclaration': case 'NamespaceDeclaration': case 'InterfaceDeclaration': case 'TypeAlias': return [statement.name.name]; case 'ImportEqualsDeclaration': // `ворид х = Н.а;` return [statement.id.name]; default: return []; } } /** Names a binding declares: `х`, or each name of a pattern (`{ а, б: [в, ...г] = [] }`). */ static patternNames(pattern) { switch (pattern.type) { case 'Identifier': return [pattern.name]; case 'ArrayPattern': return pattern.elements.flatMap(element => element ? TypeChecker.patternNames(element) : []); case 'ObjectPattern': return pattern.properties.flatMap(property => TypeChecker.patternNames((property.type === 'PropertyPattern' ? property.value : property))); case 'AssignmentPattern': return TypeChecker.patternNames(pattern.left); default: // `...рест` return TypeChecker.patternNames(pattern.argument); } } hoistFunctionDeclaration(funcDecl) { const type = this.buildFunctionType(funcDecl.name.name, funcDecl); this.declare(funcDecl.name.name, type); this.recordIdentifierType(funcDecl.name, type); } hoistVariableDeclaration(varDecl) { if (varDecl.identifier.type === 'Identifier') { const declared = varDecl.typeAnnotation ? this.resolveTypeNode(varDecl.typeAnnotation.typeAnnotation) : UNKNOWN; this.declare(varDecl.identifier.name, declared); } else { this.bindPatternTypes(varDecl.identifier, UNKNOWN); } } buildFunctionType(name, fn) { return this.withTypeParameters(fn.typeParameters, () => { const paramTypes = []; const paramNames = []; const paramOptional = []; for (const param of fn.params) { paramTypes.push(this.resolveParameterType(param)); paramNames.push(param.name.name); paramOptional.push(Boolean(param.optional) || param.defaultValue !== undefined); } const returnAnnotation = fn.returnType?.typeAnnotation; const returnType = returnAnnotation ? this.resolveTypeNode(returnAnnotation) : UNKNOWN; const predicate = returnAnnotation?.type === 'TypePredicate' ? this.resolvePredicate(returnAnnotation, fn.params) : undefined; return { kind: 'function', name, returnType, paramTypes, paramNames, paramOptional, hasRestParam: fn.params.length > 0 && Boolean(fn.params[fn.params.length - 1].rest), ...(predicate && { predicate }), }; }); } /** What a `х аст Т` / `тасдиқ х` return type says, or undefined when `х` is no parameter. */ resolvePredicate(predicate, params) { const subject = predicate.parameterName; const parameter = subject.type === 'ThisType' ? 'this' : params.findIndex(p => !p.pattern && p.name?.name === subject.name); if (parameter === -1) return undefined; return { parameter, asserts: predicate.asserts, ...(predicate.typeAnnotation && { type: this.resolveTypeNode(predicate.typeAnnotation) }), }; } /** Runs `body` with the names of `typeParameters` shadowing other types (they are unknown). */ withTypeParameters(typeParameters, body) { if (!typeParameters || typeParameters.length === 0) return body(); this.typeParameterScopes.push(new Set(typeParameters.map(param => param.name.name))); try { return body(); } finally { this.typeParameterScopes.pop(); } } resolveParameterType(param) { if (param.typeAnnotation) return this.resolveTypeNode(param.typeAnnotation.typeAnnotation); return param.rest ? { kind: 'array', elementType: UNKNOWN } : UNKNOWN; } collectInterface(interfaceDecl, allDecls, filled) { if (filled.has(interfaceDecl)) return; filled.add(interfaceDecl); this.withTypeParameters(interfaceDecl.typeParameters, () => this.collectInterfaceMembers(interfaceDecl, allDecls, filled)); } collectInterfaceMembers(interfaceDecl, allDecls, filled) { const interfaceType = this.interfaceTable.get(interfaceDecl.name.name); const properties = interfaceType.properties; // Inherited members first, so the interface's own members override them for (const parentNode of interfaceDecl.extends ?? []) { const parentName = parentNode.name; const name = typeof parentName === 'string' ? parentName : parentName?.name; allDecls .filter(d => d.name.name === name) .forEach(d => this.collectInterface(d, allDecls, filled)); const parent = this.resolveTypeNode(parentNode); for (const [key, prop] of this.getAllProperties(parent)) { if (!properties.has(key)) properties.set(key, prop); } interfaceType.indexType ?? (interfaceType.indexType = parent.indexType); interfaceType.callSignatures ?? (interfaceType.callSignatures = parent.callSignatures?.slice()); interfaceType.constructSignatures ?? (interfaceType.constructSignatures = parent.constructSignatures?.slice()); interfaceType.open || (interfaceType.open = parent.open || !['interface', 'object', 'class'].includes(parent.kind)); } this.collectPropertySignatures(interfaceDecl.body.properties, interfaceType); } /** * A method signature; several of one name (also from merged interfaces) are * overloads (`м(х: рақам): рақам; м(х: сатр): сатр;`) calls must match. * The type is named for diagnostics: "Function 'ном' expected 2 argument(s)". */ collectMethodSignature(prop, type, target) { const name = TypeChecker.signatureName(prop); const existing = target.properties.get(name); if (existing?.type.kind !== 'function') { target.properties.set(name, { type, optional: prop.optional }); return; } const overloads = existing.type.overloads ?? [existing.type]; target.properties.set(name, { type: { ...existing.type, overloads: [...overloads, type] }, optional: prop.optional && existing.optional, }); } /** `get ном(): Т;` alone is read-only; with `set ном(…)` it is not. */ collectAccessorSignature(kind, name, type, target) { const existing = target.properties.get(name); const readonly = kind === 'get' && !(existing && !existing.readonly); target.properties.set(name, { type: kind === 'set' && existing ? existing.type : type, optional: false, ...(readonly && { readonly: true }), }); } /** The member name of a signature: `ном`, or the text of `"а-б"` and `1`. */ static signatureName(prop) { return prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value); } collectPropertySignatures(signatures, target) { for (const prop of signatures) { // A computed name (`[калид]: Т`) is only known at run time if (!prop.key || !prop.typeAnnotation || prop.computed) continue; const type = this.withTypeParameters(prop.typeParameters, () => this.resolveTypeNode(prop.typeAnnotation.typeAnnotation)); if (prop.signature) { // `(х: рақам): сатр;`, `нав (х: рақам): К;`: the type is callable or constructable const signatures = prop.signature === 'call' ? (target.callSignatures ?? (target.callSignatures = [])) : (target.constructSignatures ?? (target.constructSignatures = [])); signatures.push(type); continue; } const name = TypeChecker.signatureName(prop); if (name === INDEX_SIGNATURE_KEY) { target.indexType = type; } else if (prop.method) { this.collectMethodSignature(prop, { ...type, name }, target); } else if (prop.kind) { this.collectAccessorSignature(prop.kind, name, type, target); } else { target.properties.set(name, { type, optional: prop.optional, ...(prop.readonly && { readonly: true }), }); } } } collectTypeAlias(typeAlias) { const aliasType = this.withTypeParameters(typeAlias.typeParameters, () => this.resolveTypeNode(typeAlias.typeAnnotation.typeAnnotation)); this.typeAliasTable.set(typeAlias.name.name, aliasType); } /** * Fills the class shell registered under the class name with its instance * members and links its base class by name. */ collectClass(classDecl) { const classType = this.lookup(classDecl.name.name); classType.staticMembers = new Set(); if (classDecl.abstract) classType.abstract = true; this.withTypeParameters(classDecl.typeParameters, () => this.collectClassMembers(classDecl, classType)); classType.implicitMembers = this.collectImplicitMembers(classDecl); if (classDecl.superClass) { const parentName = TypeChecker.superClassName(classDecl); const parent = parentName === undefined ? undefined : this.lookup(parentName); if (parent?.kind === 'class') { classType.baseType = parent; } else { // A built-in or imported base: its members are unknown classType.open = true; } } } collectClassMembers(classDecl, classType) { const properties = classType.properties; // Overload signatures of methods (`м(х: рақам): рақам;`), by name const overloads = new Map(); for (const member of classDecl.body.body) { if (member.type === 'StaticBlock') continue; // `[калид]() {…}`: a name only known at run time if (member.computed) continue; if (member.type === 'PropertyDefinition' && member.indexSignature) { this.collectClassIndexSignature(member, classType); continue; } if (member.static) { classType.staticMembers.add(this.memberKeyName(member.key)); continue; } if (member.type === 'PropertyDefinition') { const prop = member; const propType = prop.typeAnnotation ? this.resolveTypeNode(prop.typeAnnotation.typeAnnotation) : UNKNOWN; properties.set(this.memberKeyName(prop.key), { type: propType, optional: Boolean(prop.optional), ...(prop.readonly && { readonly: true }), }); } else if (member.type === 'MethodDefinition' && member.signature) { this.collectMethodOverload(member, overloads, properties); } else if (member.type === 'MethodDefinition') { this.collectMethod(member, properties); } } overloads.forEach((list, name) => this.attachMethodOverloads(name, list, properties)); this.collectParameterProperties(classDecl, properties); } /** A method signature without a body: an overload, or a member of an `эълон синф`. */ collectMethodOverload(member, overloads, properties) { if (member.kind !== 'method') return; const name = this.memberKeyName(member.key); const list = overloads.get(name) ?? []; list.push(this.buildFunctionType(name, member.value)); overloads.set(name, list); if (member.optional) properties.set(name, { type: list[0], optional: true }); } /** * Calls of a method with overloads are checked against them; without an * implementation (`эълон синф`, `м?(): Т;`) the signatures are the method. */ attachMethodOverloads(name, overloads, properties) { const implementation = properties.get(name); if (implementation?.type.kind === 'function' && !implementation.optional) { properties.set(name, { ...implementation, type: { ...implementation.type, overloads } }); return; } const type = overloads.length > 1 ? { ...overloads[0], overloads } : overloads[0]; properties.set(name, { type, optional: Boolean(implementation?.optional) }); } /** `[калид: сатр]: Т;` in a class: instances (or the class itself) accept any such key. */ collectClassIndexSignature(member, classType) { if (member.static) { classType.staticMembers.add(INDEX_SIGNATURE_KEY); return; } classType.indexType = member.typeAnnotation ? this.resolveTypeNode(member.typeAnnotation.typeAnnotation) : UNKNOWN; } /** The name a class member is known by: `#ном` for private names, a literal's value. */ memberKeyName(key) { if (key.type === 'PrivateIdentifier') return `#${key.name}`; if (key.type === 'Literal') return String(key.value); return key.name; } /** `конструктор(хосусӣ х: рақам)` declares the instance property `х: рақам`. */ collectParameterProperties(classDecl, properties) { for (const param of this.parameterProperties(classDecl)) { properties.set(param.name.name, { type: this.resolveParameterType(param), optional: Boolean(param.optional) && !param.defaultValue, }); } } /** Constructor parameters with `хосусӣ`/`ҷамъиятӣ`/`муҳофизатшуда`/`танҳохонӣ`. */ parameterProperties(classDecl) { const constructor = classDecl.body.body.find((member) => member.type === 'MethodDefinition' && member.kind === 'constructor'); return (constructor?.value.params ?? []).filter(param => param.accessibility || param.readonly || param.override); } /** * Field initializers run before the constructor body assigns parameter * properties, so `у = ин.х;` with `конструктор(хосусӣ х)` reads `беқимат`: * TypeScript's "used before its initialization". Functions in an * initializer run later and may read them. */ checkParameterPropertyReads(classDecl) { const names = new Set(this.parameterProperties(classDecl).map(param => param.name.name)); if (names.size === 0) return; const visit = (node) => { if (!node || typeof node !== 'object') return; const record = node; if (TypeChecker.DEFERRED_NODES.has(record.type)) return; const member = record; if (member.type === 'MemberExpression' && member.object.type === 'ThisExpression' && !member.computed && member.property.type === 'Identifier' && names.has(member.property.name)) { const name = member.property.name; this.addError(exports.TypeCheckErrorCode.UsedBeforeInitialization, (0, catalog_1.message)('USED_BEFORE_INITIALIZATION', { name }), member.property.line, member.property.column); } Object.values(record).forEach(visit); }; for (const member of classDecl.body.body) { if (member.type === 'PropertyDefinition' && !member.static) visit(member.value); } } /** * Members a class creates by assignment (`ин.ном = ном;`) without declaring * them, as JavaScript classes do. */ collectImplicitMembers(classDecl) { const names = new Set(); const visit = (node) => { if (!node || typeof node !== 'object') return; if (Array.isArray(node)) { node.forEach(visit); return; } const record = node; // Nested functions and classes have their own `ин` if (record.type === 'FunctionExpression' || record.type === 'FunctionDeclaration') return; if (record.type === 'ClassDeclaration' || record.type === 'ClassExpression') return; if (record.type === 'AssignmentExpression') { const left = record.left; if (left.type === 'MemberExpression' && left.object.type === 'ThisExpression' && !left.computed && left.property.type === 'Identifier') { names.add(left.property.name); } } Object.values(record).forEach(value => { if (value && typeof value === 'object') visit(value); }); }; for (const member of classDecl.body.body) { if (member.type === 'MethodDefinition') { visit(member.value.body); } else if (member.type === 'PropertyDefinition') { visit(member.value); } } return names; } collectMethod(method, properties) { if (method.kind === 'constructor') return; const name = this.memberKeyName(method.key); const methodType = this.buildFunctionType(name, method.value); const kind = method.kind === 'method' ? undefined : method.kind; const property = this.methodProperty(kind, methodType, properties.get(name)); // `м?() {…}`: an optional method properties.set(name, method.optional ? { ...property, optional: true } : property); } /** * The property a method defines: the method itself, or for an accessor the * getter's return type (else the setter's parameter type). A getter * without a setter is read-only. */ methodProperty(kind, methodType, existing) { if (kind === 'get') { const type = methodType.returnType; // A setter came first: it decides what may be assigned const writeType = existing && !existing.readonly ? existing.type : undefined; return { type, optional: false, ...(!existing && { readonly: true }), ...(writeType && { writeType }), }; } if (kind === 'set') { const writeType = methodType.paramTypes?.[0] ?? UNKNOWN; if (!existing) return { type: writeType, optional: false }; // `get х(): рақам` with `set х(в: рақам | сатр)` (TypeScript 5.1): reads and writes differ return { type: existing.type, optional: false, writeType }; } return { type: methodType, optional: false }; } /** Declares each enum of a statement list (once per scope) as a value and a type. */ declareEnums(declarations) { for (const statement of declarations) { if (statement.type !== 'EnumDeclaration') continue; const enumDecl = statement; if (this.declaredEnums.has(enumDecl)) continue; this.declaredEnums.add(enumDecl); const existing = this.scopes[this.scopes.length - 1].get(enumDecl.name.name); if (existing?.enumType) { // Merged enums (`шумориш Э { А } шумориш Э { Б = 1 }`) are one enum const merged = this.buildEnumType(enumDecl, existing.properties); existing.enumType = merged.enumType; } else { this.declare(enumDecl.name.name, this.buildEnumType(enumDecl)); } } } /** * The enum object: its members are `рақам` (or `сатр` for string members), * and an unknown member is reported like one of any other object. As a * type, the enum's name stands for the union of its members' types. */ buildEnumType(enumDecl, properties = new Map()) { for (const member of enumDecl.members) { const isString = this.isStringEnumInitializer(member.initializer, enumDecl, properties); properties.set(this.enumMemberName(member), { type: isString ? STRING_TYPE : NUMBER_TYPE, optional: false, }); } const memberTypes = [...properties.values()].map(prop => prop.type); const hasString = memberTypes.includes(STRING_TYPE); const hasNumber = memberTypes.includes(NUMBER_TYPE) || memberTypes.length === 0; const enumType = hasString && hasNumber ? { kind: 'union', types: [NUMBER_TYPE, STRING_TYPE] } : hasString ? STRING_TYPE : NUMBER_TYPE; return { kind: 'object', name: enumDecl.name.name, properties, enumType }; } enumMemberName(member) { return member.id.type === 'Identifier' ? member.id.name : String(member.id.value); } /** `"х"`, `` `х` ``, a string member or a concatenation with one; other members are numbers. */ isStringEnumInitializer(initializer, enumDecl, earlier) { if (!initializer) return false; const isStringMember = (name) => this.findProperty(earlier, name, (0, builtin_names_1.translateMemberName)(name))?.type === STRING_TYPE; switch (initializer.type) { case 'Literal': return typeof initializer.value === 'string'; case 'TemplateLiteral': return true; case 'Identifier': return isStringMember(initializer.name); case 'MemberExpression': { const member = initializer; return (member.object.type === 'Identifier' && member.object.name === enumDecl.name.name && member.property.type === 'Identifier' && !member.computed && isStringMember(member.property.name)); } case 'BinaryExpression': { const binary = initializer; return (binary.operator === '+' && (this.isStringEnumInitializer(binary.left, enumDecl, earlier) || this.isStringEnumInitializer(binary.right, enumDecl, earlier))); } default: return false; } } /** * Checks member initializers; earlier members are in scope by name * (`Б = А * 2`), and so are the members of the enum's earlier declarations * (`шумориш Э { А } шумориш Э { Б = А + 1 }`). */ checkEnumDeclaration(enumDecl) { const enumType = this.lookup(enumDecl.name.name); const earlier = (enumType && this.checkedEnumMembers.get(enumType)) ?? new Set(); if (enumType) this.checkedEnumMembers.set(enumType, earlier); this.withScope(() => { for (const name of earlier) { this.declare(name, enumType?.properties?.get(name)?.type ?? NUMBER_TYPE); } for (const member of enumDecl.members) { if (member.initializer) this.inferExpressionType(member.initializer); const name = this.enumMemberName(member); if (member.id.type === 'Identifier') { this.declare(name, enumType?.properties?.get(name)?.type ?? NUMBER_TYPE); earlier.add(name); } } }); } // --------------------------------------------------------------------------- // Statements // --------------------------------------------------------------------------- checkStatements(statements) { this.hoistDeclarations(statements); for (const statement of statements) { this.checkStatement(statement); } } checkStatement(statement) { this.statementHandlers[statement.type]?.(statement); } /** An expression statement; a call to an assertion function (`тасдиқ х`) narrows what follows. */ checkExpressionStatement(statement) { const expression = statement.expression; this.inferExpressionType(expression); if (expression.type === 'CallExpression') { this.applyFacts(this.assertionFacts(expression)); } } /** Checks a statement used as a body (`агар (…) х = 1;`) in its own scope. */ checkBody(statement) { if (!statement) return; if (statement.type === 'BlockStatement') { this.checkStatement(statement); } else { this.withScope(() => this.checkStatements([statement])); } } checkIfStatement(statement) { this.checkCondition(statement.test); this.inferExpressionType(statement.test); const whenTrue = this.narrowingsFor(statement.test, true); const whenFalse = this.narrowingsFor(statement.test, false); const before = this.narrowed; this.narrowed = new Map(before); this.applyFacts(whenTrue); this.checkBody(statement.consequent); const afterThen = this.narrowed; this.narrowed = new Map(before); this.applyFacts(whenFalse); this.checkBody(statement.alternate); const afterElse = this.narrowed; // A branch that always leaves (`бозгашт`, `партофтан`, …) doesn't reach the code after the `агар` const thenExits = this.alwaysExits(statement.consequent); const elseExits = this.alwaysExits(statement.alternate); if (thenExits && !elseExits) { this.narrowed = afterElse; } else if (elseExits && !thenExits) { this.narrowed = afterThen; } else { this.narrowed = this.joinNarrowed(afterThen, afterElse); } } checkWhileStatement(statement) { // Assignments in the body may run before the test is evaluated again this.invalidateAssignedIn(statement.test, statement.body); const entry = new Map(this.narrowed); this.checkCondition(statement.test); this.inferExpressionType(statement.test); this.applyFacts(this.narrowingsFor(statement.test, true)); this.checkBody(statement.body); this.narrowed = entry; if (!this.containsLoopExit(statement.body)) { this.applyFacts(this.narrowingsFor(statement.test, false)); } } /** * `кун { … } то (шарт);`: the body runs before the test. It starts with * what holds before the loop or after a true test (found by a quiet first * pass); what the body assigns is only known again once it is reassigned or * checked. */ checkDoWhileStatement(statement) { this.checkCondition(statement.test); const before = this.narrowed; this.narrowed = new Map(before); this.invalidateAssignedIn(statement.body, statement.test); // Holds anywhere in the loop: nothing the loop assigns const loopEntry = this.narrowed; this.silent++; try { this.checkDoWhileIteration(statement, loopEntry, loopEntry); this.applyFacts(this.narrowingsFor(statement.test, true)); } finally { this.silent--; } const bodyEntry = this.joinFacts(before, this.narrowed); this.checkDoWhileIteration(statement, bodyEntry, loopEntry); if (this.containsLoopExit(statement.body)) { // `шикастан` leaves without evaluating the test this.narrowed = this.joinFacts(loopEntry, this.narrowed); } else { this.applyFacts(this.narrowingsFor(statement.test, false)); } } /** Checks the body and then the test of a do-while loop, starting from `entry`. */ checkDoWhileIteration(statement, entry, loopEntry) { this.narrowed = new Map(entry); this.checkBody(statement.body); // `давом` jumps to the test from anywhere in the body if (this.containsLoopContinue(statement.body)) { this.narrowed = this.joinFacts(loopEntry, this.narrowed); } this.inferExpressionType(statement.test); } /** `берун: …`; `шикастан берун;` may leave the body from anywhere in it. */ checkLabeledStatement(statement) { const entry = new Map(this.narrowed); this.checkStatement(statement.body); if (this.breaksTo(statement.label.name, statement.body)) { const after = this.narrowed; this.narrowed = entry; this.invalidateAssignedIn(statement.body); this.narrowed = this.joinFacts(this.narrowed, after); } } checkForStatement(statement) { this.withScope(() => { if (statement.init) this.checkStatements([statement.init]); this.invalidateAssignedIn(statement.test, statement.update, statement.body); const entry = new Map(this.narrowed); if (statement.test) { this.checkCondition(statement.test); this.inferExpressionType(statement.test); this.applyFacts(this.narrowingsFor(statement.test, true)); } this.checkBody(statement.body); if (statement.update) this.inferExpressionType(statement.update); this.narrowed = entry; if (statement.test && !this.containsLoopExit(statement.body)) { this.applyFacts(this.narrowingsFor(statement.test, false)); } }); } checkForInOfStatement(statement, isForIn) { this.withScope(() => { const iterated = this.inferExpressionType(statement.right); this.invalidateAssignedIn(statement.left, statement.body); const entry = new Map(this.narrowed); const left = statement.left; if (left.type === 'VariableDeclaration') { const varDecl = left; let elementType = isForIn ? { kind: 'primitive', name: 'string' } : this.iterationElementType(iterated); // `барои интизор` awaits each element if (statement.await) { elementType = this.unionOf(this.unionMembers(elementType).map(type => this.unwrapPromise(type))); } const bound = varDecl.typeAnnotation ? this.resolveTypeNode(varDecl.typeAnnotation.typeAnnotation) : this.widenType(elementType); this.bindPatternTypes(varDecl.identifier, bound); } else { this.inferExpressionType(left); } this.checkBody(statement.body); this.narrowed = entry; }); } iterationElementType(type) { if (type.kind === 'array') return type.elementType; if (type.kind === 'tuple' && type.types && type.types.length > 0) { return { kind: 'union', types: type.types }; } if (this.isStringType(type)) return { kind: 'primitive', name: 'string' }; return UNKNOWN; } checkSwitchStatement(statement) { this.inferExpressionType(statement.discriminant); // Cases may fall through, so none of them narrows the code after the switch this.invalidateAssignedIn(statement.cases); const entry = new Map(this.narrowed); // All cases share one block scope this.withScope(() => { this.hoistDeclarations(statement.cases.flatMap(c => c.consequent)); for (const switchCase of statement.cases) { this.narrowed = new Map(entry); if (switchCase.test) this.inferExpressionType(switchCase.test); switchCase.consequent.forEach(s => this.checkStatement(s)); } }); this.narrowed = entry; } checkTryStatement(statement) { const entry = new Map(this.narrowed); this.checkStatement(statement.block); let after = this.narrowed; const handler = statement.handler; if (handler) { // The handler may start anywhere in the block this.narrowed = new Map(entry); this.invalidateAssignedIn(statement.block); const handlerEntry = this.narrowed; this.withScope(() => { // `гирифтан (е: ношинос)` / `(е: ҳар)` types the binding; untyped it is not checked const type = handler.typeAnnotation ? this.resolveTypeNode(handler.typeAnnotation.typeAnnotation) : UNKNOWN; if (handler.param) this.bindPatternTypes(handler.param, type); this.checkStatements(handler.body.body); }); if (!this.alwaysExits(handler.body)) { after = this.alwaysExits(statement.block) ? this.narrowed : this.joinNarrowed(after, this.narrowed); } this.narrowed = handlerEntry; } if (statement.finalizer) { this.narrowed = new Map(entry); this.invalidateAssignedIn(statement.block, handler); this.checkStatement(statement.finalizer); const afterFinally = this.narrowed; this.narrowed = after; this.invalidateAssignedIn(statement.finalizer); this.applyFacts(afterFinally); return; } this.narrowed = after; } checkReturnStatement(statement) { if (!statement.argument) return; const expected = this.currentFunction()?.returnType; const actual = this.inferExpressionType(statement.argument, expected); if (!expected) return; this.checkAssignable(statement.argument, actual, expected, (source, target) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.return', { source, target }), statement.argument.line, statement.argument.column)); } checkVariableDeclaration(varDecl) { let declaredType; // Get declared type if present if (varDecl.typeAnnotation) { const annotation = varDecl.typeAnnotation; declaredType = this.resolveTypeNode(annotation.typeAnnotation); } // Get inferred type from initializer let inferredType; if (varDecl.init) { const init = varDecl.init; inferredType = this.inferInitializerType(varDecl, init, declaredType); if (declaredType) { this.checkAssignable(init, inferredType, declaredType, (source, target) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE', { source, target }), init.line, init.column)); } } // Store variable type in the current scope. Unannotated bindings get the // widened type of their initializer (`тағйирёбанда х = 0` is a рақам). const finalType = declaredType ?? (inferredType ? this.widenType(inferredType, varDecl.kind === 'СОБИТ') : UNKNOWN); this.bindPatternTypes(varDecl.identifier, finalType); if (varDecl.identifier.type === 'Identifier') { const key = this.referenceKey(varDecl.identifier); if (key && varDecl.kind === 'СОБИТ') this.constKeys.add(key); // `тағ х: Г | холӣ = нав Г();` starts out as a Г const narrowed = key && declaredType && inferredType ? this.assignmentNarrowing(declaredType, inferredType) : undefined; if (key && narrowed) this.narrowed.set(key, narrowed); } } /** * Type of a variable's initializer. A class expression is named after the * variable when it has no name of its own (`собит К = синф {…}`), as in * JavaScript, and `К.ном` then reads its static members. */ inferInitializerType(varDecl, init, declaredType) { if (init.type !== 'ClassExpression' || varDecl.identifier.type !== 'Identifier') { return this.inferExpressionType(init, declaredType); } const name = varDecl.identifier.name; this.classValueKeys.add(this.bindingKey(this.scopes.length - 1, name)); return this.inferClassExpressionType(init, name); } bindPatternTypes(pattern, type) { switch (pattern.type) { case 'Identifier': this.declare(pattern.name, type); this.recordIdentifierType(pattern, type); break; case 'ArrayPattern': this.bindArrayPatternTypes(pattern, type); break; case 'ObjectPattern': this.bindObjectPatternTypes(pattern, type); break; case 'AssignmentPattern': { const assignment = pattern; this.inferExpressionType(assignment.right); this.bindPatternTypes(assignment.left, type); break; } case 'SpreadElement': case 'RestElement': this.bindPatternTypes(pattern.argument, type); break; } } bindArrayPatternTypes(pattern, type) { const elementType = type.kind === 'array' ? type.elementType : UNKNOWN; pattern.elements.forEach((element, index) => { if (!element) return; if (element.type === 'SpreadElement' || element.type === 'RestElement') { this.bindPatternTypes(element, { kind: 'array', elementType }); } else if (type.kind === 'tuple') { this.bindPatternTypes(element, type.types?.[index] ?? UNKNOWN); } else { this.bindPatternTypes(element, elementType); } }); } bindObjectPatternTypes(pattern, type) { const properties = this.getAllProperties(type); for (const prop of pattern.properties) { if (prop.type !== 'PropertyPattern') { this.bindPatternTypes(prop, UNKNOWN); continue; } // `{ [калид]: қимат }`: the property is only known at run time if (prop.computed) this.inferExpressionType(prop.key); const keyName = prop.key.type === 'Identifier' ? prop.key.name : String(prop.key.value); const propType = prop.computed ? undefined : properties.get(keyName); this.bindPatternTypes(prop.value, propType?.type ?? UNKNOWN); } } checkFunctionDeclaration(funcDecl) { // Reuse the signature hoisted into this scope const hoisted = this.scopes[this.scopes.length - 1].get(funcDecl.name.name); const functionType = hoisted?.kind === 'function' ? hoisted : this.buildFunctionType(funcDecl.name.name, funcDecl); this.checkFunctionBody(funcDecl, functionType, undefined); } /** * Checks parameters (defaults, destructuring) and the body of a function in * a new scope, with `бозгашт` checked against the declared return type. */ checkFunctionBody(fn, functionType, thisType, closure = false) { this.withTypeParameters(fn.typeParameters, () => { // `функсия ф(ин: Т)`: `ин` has the declared type in the body const declaredThis = fn.thisType ? this.resolveTypeNode(fn.thisType.typeAnnotation) : thisType; this.checkFunctionBodyIn(fn, functionType, declaredThis, closure); }); } checkFunctionBodyIn(fn, functionType, thisType, closure) { const isAsync = Boolean(fn.async ?? fn.isAsync); this.checkPredicateParameter(fn); this.functionStack.push({ // A generator's declared type (`Generator<рақам>`, `Iterable<рақам>`) describes // what it yields, not what `бозгашт` returns; `илова(): ин` returns the // receiver: here, the class being checked returnType: fn.generator ? undefined : this.expectedReturnType(this.bindThis(functionType.returnType, thisType), isAsync), thisType, }); // The body may run at any later time: a closure only keeps what is known // about variables that are never reassigned. const outer = this.narrowed; this.narrowed = new Map(closure ? [...outer].filter(([key]) => this.isNeverReassigned(key)) : []); this.withScope(() => { fn.params.forEach((param, index) => this.bindParameter(param, functionType.paramTypes?.[index] ?? UNKNOWN)); if (fn.body.type === 'BlockStatement') { this.checkStatements(fn.body.body); } else { this.checkReturnStatement({ type: 'ReturnStatement', argument: fn.body, line: fn.body.line, column: fn.body.column, }); } }); this.narrowed = outer; this.functionStack.pop(); } /** `х аст Т` / `тасдиқ х` must name a parameter of the function. */ checkPredicateParameter(fn) { const annotation = fn.returnType?.typeAnnotation; if (annotation?.type !== 'TypePredicate') return; const subject = annotation.parameterName; if (subject.type !== 'Identifier') return; const name = subject.name; if (fn.params.some(param => !param.pattern && param.name?.name === name)) return; this.addError(exports.TypeCheckErrorCode.UndefinedIdentifier, (0, catalog_1.message)('UNDEFINED_IDENTIFIER.parameter', { name }), subject.line, subject.column); } bindParameter(param, paramType) { if (param.defaultValue) { const defaultValue = param.defaultValue; const defaultType = this.inferExpressionType(defaultValue, paramType); this.checkAssignable(defaultValue, defaultType, paramType, (source, target) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE', { source, target }), defaultValue.line, defaultValue.column)); } // `а?: рақам` is `рақам | беқимат` inside the function const boundType = param.optional && !param.defaultValue ? this.optionalType(paramType) : paramType; if (param.pattern) { this.bindPatternTypes(param.pattern, boundType); } else if (param.name) { this.declare(param.name.name, boundType); this.recordIdentifierType(param.name, boundType); } } expectedReturnType(returnType, isAsync) { let expected = returnType; if (expected && isAsync) { expected = this.isPromiseType(expected) ? expected.typeParameters?.[0] : undefined; } if (!expected || expected.kind === 'unknown') return undefined; if (expected.kind === 'primitive' && ['void', 'any', 'unknown'].includes(expected.name)) { return undefined; } return expected; } checkClassDeclaration(classDecl) { // Phase 2: Validate class relationships, property types and method bodies this.validateSuperClass(classDecl); this.checkDecorators(classDecl); this.checkOverrides(classDecl); this.checkParameterPropertyReads(classDecl); this.withTypeParameters(classDecl.typeParameters, () => this.checkClassMembers(classDecl)); } /** Decorator expressions (`@ном(…)`) of a class, its members and their parameters. */ checkDecorators(classDecl) { const decorators = [...(classDecl.decorators ?? [])]; for (const member of classDecl.body.body) { if (member.type === 'StaticBlock') continue; decorators.push(...(member.decorators ?? [])); if (member.type === 'MethodDefinition') { member.value.params.forEach(param => decorators.push(...(param.decorators ?? []))); } } decorators.forEach(decorator => this.inferExpressionType(decorator.expression)); } /** * A `бознавис` (override) member must override something: TypeScript's * TS4112 (no base class) and TS4113 (the base class lacks the member). */ checkOverrides(classDecl) { const overriding = this.overridingMembers(classDecl); if (overriding.length === 0) return; const baseName = TypeChecker.superClassName(classDecl); const base = baseName === undefined ? undefined : this.lookup(baseName); for (const member of overriding) { const reason = this.invalidOverrideReason(classDecl, base, member); if (reason) { this.addError(exports.TypeCheckErrorCode.InvalidOverride, reason, member.line, member.column); } } } /** Members and parameter properties marked `бознавис`. */ overridingMembers(classDecl) { const overriding = []; for (const member of classDecl.body.body) { if (member.type === 'StaticBlock' || !member.override || member.computed) continue; const name = this.memberKeyName(member.key); overriding.push({ name, isStatic: member.static, line: member.line, column: member.column }); } for (const param of this.parameterProperties(classDecl)) { if (param.override) overriding.push({ ...param, name: param.name.name, isStatic: false }); } return overriding; } /** Why `member` overrides nothing, or undefined when it does (or the base is unknown). */ invalidOverrideReason(classDecl, base, member) { if (!classDecl.superClass) { return (0, catalog_1.message)('INVALID_OVERRIDE.noBase', { class: classDecl.name.name }); } if (base?.kind !== 'class' || this.isOpenType(base)) return undefined; const jsName = (0, builtin_names_1.translateMemberName)(member.name); const exists = member.isStatic ? this.hasStaticMember(base, member.name, jsName) : Boolean(this.findProperty(this.getAllProperties(base), member.name, jsName)) || this.hasImplicitMember(base, member.name, jsName); return exists ? undefined : (0, catalog_1.message)('INVALID_OVERRIDE.notInBase', { base: base.name }); } checkClassMembers(classDecl) { const classType = this.lookup(classDecl.name.name); if (classType) this.classStack.push(classType); try { this.checkClassMemberBodies(classDecl, classType); } finally { if (classType) this.classStack.pop(); } } checkClassMemberBodies(classDecl, classType) { for (const member of classDecl.body.body) { if (member.type === 'StaticBlock') { this.checkStaticBlock(member); continue; } const thisType = member.static ? undefined : classType; // A computed name (`[Symbol.iterator]()`, `[калид] = 1`) is an expression of the outer scope if (member.computed) this.inferExpressionType(member.key); // Signatures without a body (overloads, `эълон синф`) and index signatures if (member.type === 'MethodDefinition' && member.signature) continue; if (member.type === 'PropertyDefinition' && member.indexSignature) continue; if (member.type === 'PropertyDefinition') { this.functionStack.push({ thisType }); this.validatePropertyDefinition(member); this.functionStack.pop(); } else if (member.type === 'MethodDefinition') { const method = member; const methodType = this.buildFunctionType(this.memberKeyName(method.key), method.value); this.checkFunctionBody(method.value, methodType, thisType); } } } /** `статикӣ { … }` runs once, like a function body without parameters; `ин` is the class. */ checkStaticBlock(block) { const body = { type: 'BlockStatement', body: block.body, line: block.line, column: block.column, }; this.checkFunctionBody({ params: [], body }, { kind: 'function', returnType: UNKNOWN }, undefined, true); } /** * A class expression has the class itself as its type, as a declaration * does; `bindingName` names a class without a name of its own. */ inferClassExpressionType(classExpr, bindingName) { const name = classExpr.name?.name ?? bindingName ?? '(Anonymous class)'; const classDecl = { ...classExpr, type: 'ClassDeclaration', name: classExpr.name ?? { type: 'Identifier', name, line: classExpr.line, column: classExpr.column, }, }; let classType = UNKNOWN; // The class's own name is bound inside its body only this.withScope(() => { this.declareClassShell(classDecl); classType = this.lookup(name); this.classValueKeys.add(this.bindingKey(this.scopes.length - 1, name)); this.collectClass(classDecl); this.checkClassDeclaration(classDecl); }); return classType; } /** The name of a class's base class, or undefined for none or an expression (`Омехта(А)`). */ static superClassName(classDecl) { const superClass = classDecl.superClass; return superClass?.type === 'Identifier' ? superClass.name : undefined; } validateSuperClass(classDecl) { if (!classDecl.superClass) return; const parentName = TypeChecker.superClassName(classDecl); // `мерос Н.Асос`, `мерос Омехта(Асос)`: the expression is checked, its class is not known if (parentName === undefined) { this.inferExpressionType(classDecl.superClass); return; } const parentType = this.lookup(parentName); const interfaceType = this.interfaceTable.get(parentName); if (interfaceType) { this.addError(exports.TypeCheckErrorCode.InvalidExtends, (0, catalog_1.message)('INVALID_EXTENDS', { class: classDecl.name.name, parent: parentName, kind: 'interface', }), classDecl.line, classDecl.column); return; } if (!parentType) { if (!this.isBuiltinValueName(parentName)) { this.addError(exports.TypeCheckErrorCode.ClassNotFound, (0, catalog_1.message)('CLASS_NOT_FOUND', { name: parentName }), classDecl.line, classDecl.column); } return; } // Imported or otherwise untyped bases can't be validated, nor can a `ҳар` // value (a mixin's base: `(Асос: ҳар) => синф мерос Асос { … }`) if (parentType.kind === 'unknown' || (parentType.kind === 'primitive' && parentType.name === 'any')) { return; } if (parentType.kind !== 'class') { this.addInvalidExtendsError(classDecl, parentType); return; } this.checkCircularInheritance(classDecl.name.name, parentType, classDecl.line, classDecl.column); } addInvalidExtendsError(classDecl, parentType) { this.addError(exports.TypeCheckErrorCode.InvalidExtends, (0, catalog_1.message)('INVALID_EXTENDS', { class: classDecl.name.name, parent: TypeChecker.superClassName(classDecl), kind: parentType.kind, }), classDecl.line, classDecl.column); } validatePropertyDefinition(prop) { if (!prop.value) return; const value = prop.value; const declaredType = prop.typeAnnotation ? this.resolveTypeNode(prop.typeAnnotation.typeAnnotation) : undefined; const inferredType = this.inferExpressionType(value, declaredType); if (!declaredType) return; this.checkAssignable(value, inferredType, declaredType, (source, target) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.property', { source, target, property: this.memberKeyName(prop.key), }), prop.line, prop.column)); } /** * Check for circular inheritance in class hierarchy by walking the base * chain from the parent; reaching the class itself means a cycle. */ checkCircularInheritance(className, parentType, line, column) { const visited = new Set(); for (let current = parentType; current; current = current.baseType) { if (current.name === className) { const circular = (0, catalog_1.message)(current === parentType ? 'CIRCULAR_INHERITANCE.self' : 'CIRCULAR_INHERITANCE', { class: className }); this.addError(exports.TypeCheckErrorCode.CircularInheritance, circular, line, column); return; } if (visited.has(current.name)) return; visited.add(current.name); } } // --------------------------------------------------------------------------- // Type annotations // --------------------------------------------------------------------------- resolveTypeNode(typeNode) { switch (typeNode.type) { case 'PrimitiveType': return this.resolvePrimitiveType(typeNode); case 'ArrayType': return this.resolveArrayType(typeNode); case 'UnionType': return this.resolveUnionType(typeNode); case 'IntersectionType': return this.resolveIntersectionType(typeNode); case 'TupleType': return this.resolveTupleType(typeNode); case 'GenericType': return this.resolveGenericType(typeNode); case 'UniqueType': return this.resolveUniqueType(typeNode); case 'LiteralType': return this.resolveLiteralType(typeNode); case 'ObjectType': return this.resolveObjectType(typeNode); case 'Identifier': return this.resolveIdentifierType(typeNode); case 'FunctionType': { const fnType = typeNode; // `<Т>(х: Т) => Т`: `Т` is a type parameter in the signature return this.withTypeParameters(fnType.typeParameters, () => this.buildFunctionType(undefined, { params: fnType.parameters, returnType: { type: 'TypeAnnotation', typeAnnotation: fnType.returnType, line: 0, column: 0, }, })); } default: return this.resolveTypeOperator(typeNode); } } /** `танҳохонӣ Т[]`, `ин`, `нав () => Т`, and a type predicate as a return type (a мантиқӣ). */ resolveTypeOperator(typeNode) { switch (typeNode.type) { case 'ReadonlyType': // An array or tuple type (the parser reports any other operand) return { ...this.resolveTypeNode(typeNode.typeAnnotation), readonly: true, }; case 'ThisType': return THIS_TYPE; case 'TypePredicate': return typeNode.asserts ? VOID_TYPE : BOOLEAN_TYPE; case 'ConstructorType': { const constructorType = typeNode; return this.withTypeParameters(constructorType.typeParameters, () => ({ ...this.buildFunctionType(undefined, { params: constructorType.parameters, returnType: { type: 'TypeAnnotation', typeAnnotation: constructorType.returnType, line: 0, column: 0, }, }), kind: 'constructor', })); } case 'OptionalType': case 'RestType': return this.resolveTypeNode(typeNode.typeAnnotation); case 'TemplateLiteralType': // `пеш_${К}` is approximated as a string return STRING_TYPE; default: return UNKNOWN; } } resolvePrimitiveType(primitiveType) { return { kind: 'primitive', name: this.mapTajikToPrimitive(primitiveType.name) }; } resolveLiteralType(literalType) { // A bigint literal type (`1n`), like a bigint literal value, is not a рақам if (literalType.bigint) return UNKNOWN; return { kind: 'literal', value: literalType.value }; } resolveArrayType(arrayType) { return { kind: 'array', elementType: this.resolveTypeNode(arrayType.elementType), }; } resolveUnionType(unionType) { return { kind: 'union', types: unionType.types.map(t => this.resolveTypeNode(t)), }; } resolveIntersectionType(intersectionType) { return { kind: 'intersection', types: intersectionType.types.map(t => this.resolveTypeNode(t)), }; } /** `[рақам, сатр?, ...мантиқӣ[]]`: optional elements set `minLength`, a rest element `restType`. */ resolveTupleType(tupleType) { const elements = tupleType.elementTypes; const restIndex = elements.findIndex(element => element.type === 'RestType'); if (restIndex !== -1 && restIndex !== elements.length - 1) { // `[...Т[], У]`: elements after a rest element are not tracked return { kind: 'array', elementType: UNKNOWN }; } const fixed = restIndex === -1 ? elements : elements.slice(0, restIndex); const tuple = { kind: 'tuple', types: fixed.map(t => this.resolveTypeNode(t)) }; const optionalIndex = fixed.findIndex(element => element.type === 'OptionalType'); if (optionalIndex !== -1) tuple.minLength = optionalIndex; if (restIndex !== -1) { const rest = this.resolveTypeNode(elements[restIndex]); tuple.restType = rest.kind === 'array' ? rest.elementType : UNKNOWN; } return tuple; } /** Type a tuple has at `index`: the element (with `беқимат` when optional) or the rest element. */ tupleElementAt(tuple, index) { const types = tuple.types; if (index >= types.length) return tuple.restType; const optional = index >= (tuple.minLength ?? types.length); return optional ? this.optionalType(types[index]) : types[index]; } /** Whether a tuple type has room for exactly `length` elements. */ tupleAccepts(tuple, length) { const types = tuple.types; return (length >= (tuple.minLength ?? types.length) && (tuple.restType !== undefined || length <= types.length)); } resolveObjectType(objectType) { const type = { kind: 'object', properties: new Map() }; this.collectPropertySignatures(objectType.properties, type); return type; } resolveGenericType(genericType) { const baseName = genericType.name.name; const typeParams = (genericType.typeParameters ?? []).map(tp => this.resolveTypeNode(tp)); if (PROMISE_NAMES.has(baseName)) { return { kind: 'generic', name: 'Promise', typeParameters: typeParams }; } const baseType = this.resolveNamedType(baseName); if (baseType.kind === 'unknown') this.checkTypeName(genericType.name); // Add type parameters for generic types if (typeParams.length > 0) { // For Map and Set, explicitly mark as generic if (baseName === 'Map' || baseName === 'Set') { return { kind: 'generic', name: baseName, typeParameters: typeParams, }; } // For type aliases and other generics, preserve the base type kind and add type parameters return { ...baseType, typeParameters: typeParams, }; } return baseType; } resolveUniqueType(uniqueType) { return { kind: 'unique', baseType: this.resolveTypeNode(uniqueType.baseType) }; } resolveIdentifierType(identifierType) { if (PROMISE_NAMES.has(identifierType.name)) { return { kind: 'generic', name: 'Promise', typeParameters: [] }; } const type = this.resolveNamedType(identifierType.name); if (type.kind === 'unknown') this.checkTypeName(identifierType); return type; } /** * Reports a type name the program neither declares nor has built in, once: * a typo such as `мантики` for `мантиқӣ` (an error with `strict`). */ checkTypeName(name) { if (this.reportedTypeNames.has(name) || !(0, type_names_1.isUnknownTypeName)(name.name, this.declaredTypes)) { return; } if (this.silent > 0) return; this.reportedTypeNames.add(name); const suggestion = (0, suggest_1.closestName)(name.name, [...type_names_1.TYPE_NAMES.keys(), ...this.declaredTypes]); const report = this.strict ? this.addError.bind(this) : this.addWarning.bind(this); report(exports.TypeCheckErrorCode.TypeNotFound, (0, catalog_1.message)('TYPE_NOT_FOUND', suggestion === undefined ? { name: name.name } : { name: name.name, suggestion }), name.line, name.column); } resolveNamedType(typeName) { // A type parameter (`<Т>`) shadows types of the same name if (this.typeParameterScopes.some(scope => scope.has(typeName))) { return { kind: 'unknown', name: typeName }; } // Check if it's a known interface or type alias const interfaceType = this.interfaceTable.get(typeName); if (interfaceType) { return interfaceType; } const aliasType = this.typeAliasTable.get(typeName); if (aliasType) { return aliasType; } // Check if it's a class type const classType = this.lookup(typeName); if (classType && classType.kind === 'class') { return classType; } // An enum's name is also the type of its members: `тағ р: Ранг = Ранг.Сурх;` if (classType?.enumType) { return classType.enumType; } // Unknown type return { kind: 'unknown', name: typeName }; } mapTajikToPrimitive(tajikType) { switch (tajikType) { case 'сатр': return 'string'; case 'рақам': return 'number'; case 'мантиқӣ': return 'boolean'; case 'холӣ': return 'null'; case 'беқимат': return 'undefined'; case 'ҳар': return 'any'; case 'ношинос': return 'unknown'; case 'абадан': return 'never'; case 'беджавоб': return 'void'; case 'объект': return 'object'; case 'рамз': return 'symbol'; default: return 'unknown'; } } // --------------------------------------------------------------------------- // Expressions // --------------------------------------------------------------------------- inferExpressionType(expression, targetType) { const handler = this.expressionHandlers[expression.type]; return handler ? handler(expression, targetType) : UNKNOWN; } inferLiteralType(literal) { if (typeof literal.value === 'number' && /n$/.test(literal.raw)) { // BigInt literal (`10n`): not a рақам return UNKNOWN; } if (literal.value === null) return { kind: 'primitive', name: 'null' }; // A literal type, for better type inference return { kind: 'literal', value: literal.value }; } /** `чоп`, `математика`, … naming the built-in object, not a binding of that name. */ isBuiltinReference(expression) { return (expression.type === 'Identifier' && (0, builtin_globals_1.isCheckedBuiltinObject)(expression.name) && !this.lookup(expression.name)); } /** A declared or built-in name close to `name`, for "did you mean". */ similarName(name) { const names = new Set(); this.scopes.forEach(scope => scope.forEach((_type, declared) => names.add(declared))); TypeChecker.BUILTIN_VALUE_NAMES.forEach(builtin => names.add(builtin)); INPUT_FUNCTION_TYPES.forEach((_type, input) => names.add(input)); return (0, suggest_1.closestName)(name, names); } /** A member of `type` close to `name`: its own members and the Tajik names of built-in ones. */ similarMember(name, type) { const candidates = new Set(); for (const member of this.unionMembers(type)) { const builtin = this.builtinMembersOf(member); if (builtin) { for (const [alias, jsName] of builtin_names_1.BUILTIN_MAPPINGS) { if (builtin_names_1.MEMBER_ALIASES.has(alias) && builtin.has(jsName)) candidates.add(alias); } } this.getAllProperties(member).forEach((_property, key) => candidates.add(key)); } return (0, suggest_1.closestName)(name, candidates); } isBuiltinValueName(name) { return TypeChecker.BUILTIN_VALUE_NAMES.has(name) || name in global; } inferIdentifierType(identifier) { const type = this.identifierValueType(identifier); this.recordIdentifierType(identifier, type); return type; } identifierValueType(identifier) { const sym = this.lookup(identifier.name); if (sym?.typeOnly) { this.addError(exports.TypeCheckErrorCode.TypeOnlyImportValue, (0, catalog_1.message)('TYPE_ONLY_IMPORT_VALUE', { name: identifier.name }), identifier.line, identifier.column); return UNKNOWN; } if (sym) { return this.narrowed.get(this.referenceKey(identifier)) ?? sym; } if (identifier.name === 'беқимат' || identifier.name === 'undefined') return UNDEFINED_TYPE; const input = INPUT_FUNCTION_TYPES.get(identifier.name); if (input) return input; // Empty names are parser error-recovery placeholders if (!identifier.name || this.isBuiltinValueName(identifier.name)) { return UNKNOWN; } this.addError(exports.TypeCheckErrorCode.UndefinedIdentifier, (0, catalog_1.message)('UNDEFINED_IDENTIFIER', { name: identifier.name, suggestion: this.similarName(identifier.name), }), identifier.line, identifier.column); return UNKNOWN; } inferTupleTypeFromTarget(arrayExpr, targetType) { const inferredTypes = []; for (let i = 0; i < arrayExpr.elements.length; i++) { const element = arrayExpr.elements[i]; const targetElementType = this.tupleElementAt(targetType, i) ?? UNKNOWN; // A hole (`[1, , 3]`) is `беқимат` const inferredType = element ? this.inferExpressionType(element, targetElementType) : UNDEFINED_TYPE; inferredTypes.push(inferredType); } return { kind: 'tuple', types: inferredTypes }; } unifyElementTypes(elementTypes) { const firstType = elementTypes[0]; const baseType = this.getBaseType(firstType); // Check if all elements have the same base type const allSameBase = elementTypes.every((t) => { const tBase = this.getBaseType(t); return this.isExactMatch(tBase, baseType); }); if (allSameBase) { return baseType; } // Mixed types: array of union type return { kind: 'union', types: elementTypes }; } inferArrayExpressionType(arrayExpr, contextType) { const elements = arrayExpr.elements.filter((element) => !!element); const hasSpread = elements.some(e => e.type === 'SpreadElement'); const targetType = this.arrayContextType(contextType, elements.length); // If target type is a tuple, use bidirectional inference if (targetType && targetType.kind === 'tuple' && targetType.types && !hasSpread) { return this.inferTupleTypeFromTarget(arrayExpr, targetType); } const elementTarget = targetType?.kind === 'array' ? targetType.elementType : undefined; const elementTypes = elements.map(element => element.type === 'SpreadElement' ? this.iterationElementType(this.inferExpressionType(element.argument)) : this.inferExpressionType(element, elementTarget)); if (elementTypes.length === 0 || elementTypes.some(t => t.kind === 'unknown')) { return { kind: 'array', elementType: UNKNOWN }; } // With a contextual array type, keep each element's own type so that // assignability checks every element against the target element type if (elementTarget) { const elementType = elementTypes.length === 1 ? elementTypes[0] : this.unionOf(elementTypes); return { kind: 'array', elementType }; } return { kind: 'array', elementType: this.unifyElementTypes(elementTypes) }; } /** * Picks the member of a union target that contextually types an array * literal: a tuple of matching length, else an array type. */ arrayContextType(targetType, length) { if (targetType?.kind !== 'union' || !targetType.types) return targetType; return (targetType.types.find(t => t.kind === 'tuple' && this.tupleAccepts(t, length)) ?? targetType.types.find(t => t.kind === 'array')); } /** * Get the base type of a type, converting literals to their base primitives * E.g., { kind: 'literal', value: 5 } -> { kind: 'primitive', name: 'number' } */ /** `сатр`, `рақам` or `мантиқӣ`: the primitive of a literal type's value. */ static literalBaseName(type) { return typeof type.value === 'string' ? 'string' : typeof type.value === 'number' ? 'number' : 'boolean'; } getBaseType(type) { if (type.kind === 'literal') { return { kind: 'primitive', name: TypeChecker.literalBaseName(type) }; } return type; } /** * Type of a binding without annotation: literals become their primitive * (except for `собит` bindings), `холӣ`/`беқимат` become unknown, and * object/array members are widened since they stay mutable. */ widenType(type, keepLiteral = false) { if (type.constant) return type; switch (type.kind) { case 'literal': return keepLiteral ? type : this.getBaseType(type); case 'primitive': return type.name === 'null' || type.name === 'undefined' ? UNKNOWN : type; case 'array': return { kind: 'array', elementType: this.widenType(type.elementType), ...(type.readonly && { readonly: true }), }; case 'union': // `Г | холӣ` stays nullable: only a binding of plain `холӣ` is widened return this.unionOf(type.types.map(t => (this.isNullishType(t) ? t : this.widenType(t)))); case 'object': return this.widenObjectType(type); default: return type; } } /** An object type with its members widened (they stay mutable). */ widenObjectType(type) { const properties = new Map(); for (const [key, prop] of type.properties) { properties.set(key, { type: this.widenType(prop.type), optional: prop.optional }); } return { kind: 'object', properties, ...(type.open && { open: true }), ...(type.fromLiteral && { fromLiteral: true }), }; } inferObjectType(objExpr, targetType) { const targetProperties = targetType ? this.getAllProperties(targetType) : new Map(); const properties = new Map(); // Spread and computed keys contribute members we can't name statically let open = false; for (const prop of objExpr.properties) { if (prop.type === 'SpreadElement') { this.inferExpressionType(prop.argument); open = true; continue; } if (prop.computed) { this.inferExpressionType(prop.key); open = true; } const value = prop.value; const keyName = this.propertyKeyName(prop.key); const contextType = prop.kind ? undefined : targetProperties.get(keyName)?.type; const valueType = this.inferExpressionType(value, contextType); if (!prop.computed) { properties.set(keyName, this.methodProperty(prop.kind, valueType, properties.get(keyName))); } } // Like JavaScript objects, those built from a literal may gain members later return open ? UNKNOWN : { kind: 'object', properties, fromLiteral: true }; } propertyKeyName(key) { return key.type === 'Identifier' ? key.name : String(key.value); } inferFunctionExpressionType(fn, isArrow) { const functionType = this.buildFunctionType(undefined, fn); // Arrow functions keep the enclosing `ин` const thisType = isArrow ? this.currentFunction()?.thisType : undefined; // `функсия ном(…) { … }`: the name is bound in the function's body only this.withScope(() => { if (fn.name) this.declare(fn.name.name, functionType); this.checkFunctionBody(fn, functionType, thisType, true); }); return functionType; } isOptionalChain(expression) { let current = expression; while (current) { if (current.type === 'NonNullExpression') { // `о?.а!.б` is still one chain current = current.expression; continue; } if (current.type !== 'MemberExpression' && current.type !== 'CallExpression') break; if (current.optional) return true; current = current.type === 'MemberExpression' ? current.object : current.callee; } return false; } inferMemberType(member, ignoreNarrowing = false) { const rawObjectType = this.inferExpressionType(member.object); // `а?.б` is fine when `а` is `холӣ`; `а.б` is not const objectType = member.optional ? this.removeNullish(rawObjectType) : this.checkNotNullish(member.object, rawObjectType); const inOptionalChain = this.isOptionalChain(member); if (member.computed) { const indexType = this.inferExpressionType(member.property); if (inOptionalChain) return UNKNOWN; return this.indexedAccessType(objectType, indexType); } const property = this.memberPropertyName(member); // `илова(): ин` called on `о` returns the type of `о` const memberType = this.bindThis(this.namedMemberType(member, objectType, property), objectType); if (inOptionalChain) return UNKNOWN; const key = ignoreNarrowing ? undefined : this.referenceKey(member); return (key ? this.narrowed.get(key) : undefined) ?? memberType; } /** The property of `о.ном` / `о.#ном` (not computed) as an identifier named like the member (`#ном`). */ memberPropertyName(member) { const property = member.property; if (property.type !== 'PrivateIdentifier') return property; const name = `#${property.name}`; return { type: 'Identifier', name, line: property.line, column: property.column }; } /** `type` with `ин` (the `this` type) replaced by `receiver`, also in a method's return type. */ bindThis(type, receiver) { if (type?.kind === 'this') return receiver ?? UNKNOWN; if (type?.kind === 'function' && type.returnType?.kind === 'this') { return { ...type, returnType: receiver ?? UNKNOWN }; } if (type?.kind === 'union' && type.types?.some(t => t.kind === 'this')) { return { ...type, types: type.types.map(t => this.bindThis(t, receiver)) }; } return type; } /** * Type of `object.name` (`name` as written, possibly a Tajik alias such as * `дарозӣ`); reports members the object's type doesn't have. */ namedMemberType(member, objectType, property) { const name = property.name; // `чоп.сабтт`, `математика.решаа`: built-in objects have a fixed set of members if (this.isBuiltinReference(member.object)) { const objectName = member.object.name; if (!(0, builtin_globals_1.builtinObjectHasMember)(objectName, name)) { this.addError(exports.TypeCheckErrorCode.PropertyNotFound, (0, catalog_1.message)('PROPERTY_NOT_FOUND.builtinObject', { name, jsName: (0, builtin_globals_1.builtinObjectMemberName)(objectName, name), object: objectName, suggestion: (0, suggest_1.closestName)(name, (0, builtin_globals_1.builtinObjectMemberNames)(objectName)), }), property.line, property.column); } return UNKNOWN; } const jsName = (0, builtin_names_1.translateMemberName)(name); // `Синф.статикӣ`: the class itself, not an instance if (member.object.type === 'Identifier' && objectType.kind === 'class' && (objectType.name === member.object.name || this.classValueKeys.has(this.referenceKey(member.object)))) { if (!this.hasStaticMember(objectType, name, jsName)) { this.reportMissingMember(property, name, jsName, objectType, true); } return UNKNOWN; } // `сатр.хоми`: `сатр` as a value is the String constructor, whose members aren't listed if (this.primitiveValues.has(objectType)) return UNKNOWN; if (name.startsWith('#') && !this.hasPrivateName(objectType, name)) { this.reportMissingMember(property, name, jsName, objectType, false); return UNKNOWN; } const members = this.unionMembers(objectType); const lookups = members.map(t => this.lookupMember(t, name, jsName)); // Without discriminant narrowing a member of some union members is accepted const missing = lookups.every(l => l.known && !l.exists); if (missing && lookups.length > 0) { this.reportMissingMember(property, name, jsName, objectType, false); return UNKNOWN; } return lookups.length === 1 ? lookups[0].type : UNKNOWN; } /** * `о.#ном` names the `#ном` of the innermost enclosing class declaring it; * only instances of that class (and its subclasses) have it. */ hasPrivateName(objectType, name) { const owner = [...this.classStack] .reverse() .find(c => c.properties?.has(name) || c.staticMembers?.has(name)); if (!owner) return true; return this.unionMembers(objectType).every(type => { if (type.kind !== 'class') return true; const visited = new Set(); for (let t = type; t && !visited.has(t); t = t.baseType) { if (t === owner) return true; visited.add(t); } return false; }); } /** * Looks up a member on one (non-union) type. `known` is false when the * type's members can't be listed (unresolved types, `ҳар`, open object * types, …), so a missing member must not be reported. */ lookupMember(type, name, jsName) { const builtin = this.builtinMembersOf(type); // Members `эълон глобалӣ { интерфейс Array<Т> { … } }` adds const augmented = this.augmentedMember(type, name, jsName); if (builtin) { // A `танҳохонӣ` array has no methods that change it const removed = type.readonly && MUTATING_ARRAY_METHODS.has(jsName); return { known: true, exists: (builtin.has(jsName) && !removed) || augmented !== undefined, type: augmented?.type ?? this.builtinMemberType(type, jsName), }; } if (!['class', 'interface', 'object'].includes(type.kind) || !type.properties) { return { known: false, exists: true, type: this.getAllProperties(type).get(name)?.type ?? UNKNOWN, }; } const prop = this.findProperty(this.getAllProperties(type), name, jsName); const exists = Boolean(prop) || exports.BUILTIN_MEMBERS.object.has(jsName) || augmented !== undefined || this.hasImplicitMember(type, name, jsName); const known = !this.isOpenType(type) && !type.fromLiteral; let propType = prop?.type ?? UNKNOWN; if (prop?.optional) propType = this.optionalType(propType); return { known, exists, type: propType }; } /** Property named `name` or, for built-in aliases, its translation (`дарозӣ` ≡ `length`). */ findProperty(properties, name, jsName) { const direct = properties.get(name) ?? properties.get(jsName); if (direct) return direct; for (const [key, prop] of properties) { if ((0, builtin_names_1.translateMemberName)(key) === jsName) return prop; } return undefined; } /** Whether an object type may have members the checker doesn't know about. */ isOpenType(type) { for (let t = type, depth = 0; t && depth < 100; t = t.baseType, depth++) { if (t.open || t.indexType) return true; } return false; } hasImplicitMember(type, name, jsName) { for (let t = type, depth = 0; t && depth < 100; t = t.baseType, depth++) { if (t.implicitMembers?.has(name) || t.implicitMembers?.has(jsName)) return true; } return false; } hasStaticMember(classType, name, jsName) { // A class is a function: `name`, `call`, … and its own `prototype` if (jsName === 'prototype' || exports.BUILTIN_MEMBERS.function.has(jsName)) return true; if (this.isOpenType(classType)) return true; for (let t = classType, depth = 0; t && depth < 100; t = t.baseType, depth++) { for (const member of t.staticMembers ?? []) { // `статикӣ [калид: сатр]: Т;` accepts every name if (member === INDEX_SIGNATURE_KEY) return true; if (member === name || (0, builtin_names_1.translateMemberName)(member) === jsName) return true; } } return false; } /** Member names of a built-in type, or undefined for other types. */ builtinMembersOf(type) { if (type.kind === 'array' || type.kind === 'tuple') return exports.BUILTIN_MEMBERS.array; if (this.isStringType(type)) return exports.BUILTIN_MEMBERS.string; if (this.isNumericType(type)) return exports.BUILTIN_MEMBERS.number; const base = this.getBaseType(type); if (base.kind === 'primitive' && base.name === 'boolean') return exports.BUILTIN_MEMBERS.boolean; if (type.kind === 'generic' && ['Map', 'Set', 'Promise', 'RegExp'].includes(type.name)) { return exports.BUILTIN_MEMBERS[type.name]; } return undefined; } /** Types of the built-in members the checker knows more about than "exists". */ builtinMemberType(type, jsName) { if (type.kind === 'generic') return this.collectionMemberType(type, jsName); const isArray = type.kind === 'array' || type.kind === 'tuple'; if (jsName === 'length' && (isArray || this.isStringType(type))) return NUMBER_TYPE; if (isArray && ARRAY_ELEMENT_OR_UNDEFINED.has(jsName)) { return this.methodReturning(this.orUndefined(this.iterationElementType(type))); } if (this.isStringType(type) && jsName === 'at') { return this.methodReturning(this.orUndefined(STRING_TYPE)); } return UNKNOWN; } /** Members of `Map<К, В>` / `Set<Т>` / `RegExp` with known types. */ collectionMemberType(type, jsName) { if ((type.name === 'Map' || type.name === 'Set') && jsName === 'size') return NUMBER_TYPE; if (type.name === 'RegExp') { if (jsName === 'test') return this.methodReturning({ kind: 'primitive', name: 'boolean' }); if (jsName === 'lastIndex') return NUMBER_TYPE; if (jsName === 'source' || jsName === 'flags') return STRING_TYPE; } if (type.name === 'Map' && jsName === 'get') { return this.methodReturning(this.orUndefined(type.typeParameters?.[1] ?? UNKNOWN)); } return UNKNOWN; } /** A method whose arguments aren't checked and whose result has type `returnType`. */ methodReturning(returnType) { return returnType.kind === 'unknown' ? UNKNOWN : { kind: 'function', returnType }; } reportMissingMember(property, name, jsName, objectType, isStatic) { const isMapOrSet = this.unionMembers(objectType).some(t => t.kind === 'generic' && (t.name === 'Map' || t.name === 'Set')); const suggestion = isStatic ? undefined : this.similarMember(name, objectType); const missing = isStatic ? (0, catalog_1.message)('PROPERTY_NOT_FOUND.static', { name, jsName, class: objectType.name }) : (0, catalog_1.message)('PROPERTY_NOT_FOUND', { name, jsName, type: this.typeToString(objectType), mapSet: isMapOrSet && jsName === 'includes' ? 'yes' : undefined, suggestion, }); // Reading `о.#ном` from an object whose class doesn't declare `#ном` always throws const report = this.strict || name.startsWith('#') ? this.addError.bind(this) : this.addWarning.bind(this); report(exports.TypeCheckErrorCode.PropertyNotFound, missing, property.line, property.column); } indexedAccessType(objectType, indexType) { if (!this.isNumericType(indexType)) return UNKNOWN; if (objectType.kind === 'array') return objectType.elementType; if (objectType.kind === 'tuple' && indexType.kind === 'literal') { return this.tupleElementAt(objectType, indexType.value) ?? UNKNOWN; } return UNKNOWN; } inferAssignmentType(assignment) { const left = assignment.left; // `х! = 1` and `(х чун Т) = 1` assign to `х` const reference = this.skipAssertions(left); const isReference = reference.type === 'Identifier' || reference.type === 'MemberExpression'; const isPlain = assignment.operator === '='; if (this.checkConstTarget(reference)) { return this.inferExpressionType(assignment.right); } // The target accepts its declared type, not what an earlier check narrowed it to const leftType = this.inferAssignmentTargetType(left); this.checkReadonlyTarget(left); if (this.isArithmeticAssignment(assignment.operator, leftType)) { this.checkNotNullish(left, leftType); } const rightType = this.inferExpressionType(assignment.right, isPlain ? leftType : undefined); if (isPlain && isReference) { this.checkAssignable(assignment.right, rightType, leftType, (source, target) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE', { source, target }), assignment.right.line, assignment.right.column)); } if (isPlain || assignment.operator === '??=') { const assigned = isPlain ? rightType : this.removeNullish(leftType); if (reference === left || left.type === 'NonNullExpression') { // `х! = 1` narrows `х` like `х = 1` does const declared = reference === left ? leftType : this.inferAssignmentTargetType(reference); this.narrowOnAssignment(reference, declared, assigned); } else { // Through `(х чун Т)` the assignment only invalidates what was known about `х` this.invalidate(this.referenceKey(reference)); } } this.forEachNode(left, node => { // Destructuring assignment: forget what was known about each target if (!isReference) { if (node.type === 'Identifier' || node.type === 'MemberExpression') { this.invalidate(this.referenceKey(node)); } } }); return rightType; } /** Reports a new value for a `собит` (`х = 2`, `х++`); true when it is one. */ checkConstTarget(target) { if (target.type !== 'Identifier') return false; const key = this.referenceKey(target); if (key === undefined || !this.constKeys.has(key)) return false; this.addError(exports.TypeCheckErrorCode.ConstAssignment, (0, catalog_1.message)('CONST_ASSIGNMENT', { name: target.name }), target.line, target.column); return true; } inferAssignmentTargetType(target) { if (target.type === 'NonNullExpression') { const inner = target.expression; return this.removeNullish(this.inferAssignmentTargetType(inner)); } if (target.type === 'MemberExpression') { return (this.memberWriteType(target) ?? this.inferMemberType(target, true)); } if (target.type === 'Identifier') { const declared = this.lookup(target.name); if (declared) return declared; } return this.inferExpressionType(target); } /** What `о.х = …` may assign when `х` has a setter whose type differs from its getter's. */ memberWriteType(member) { if (member.computed || member.property.type !== 'Identifier') return undefined; const objectType = this.removeNullish(this.quietType(member.object)); if (!['class', 'interface', 'object'].includes(objectType.kind)) return undefined; const name = member.property.name; const property = this.findProperty(this.getAllProperties(objectType), name, (0, builtin_names_1.translateMemberName)(name)); return property?.writeType; } /** * `р[0] = 1` / `р[0]++` on a `танҳохонӣ` array or tuple, `о.х = 1` on a * `танҳохонӣ х` property: an error in strict mode, a warning otherwise. */ checkReadonlyTarget(target) { if (target.type !== 'MemberExpression') return; const member = target; const objectType = this.removeNullish(this.quietType(member.object)); const readonly = this.readonlyMemberMessage(member, objectType); if (!readonly) return; const report = this.strict ? this.addError.bind(this) : this.addWarning.bind(this); report(exports.TypeCheckErrorCode.ReadonlyAssignment, readonly, member.line, member.column); } readonlyMemberMessage(member, objectType) { const list = this.unionMembers(objectType).find(t => t.readonly); if (list) { return (0, catalog_1.message)('READONLY_ASSIGNMENT.element', { reference: this.referencePath(member.object), type: this.typeToString(list), }); } const property = member.computed ? undefined : this.memberPropertyName(member); // `ин.ном = …` initialises the property in the constructor; `Синф.ном` is a static const isClassItself = member.object.type === 'Identifier' && objectType.kind === 'class' && objectType.name === member.object.name; if (!property || member.object.type === 'ThisExpression' || isClassItself) return undefined; const name = property.name; const declared = this.findProperty(this.getAllProperties(objectType), name, (0, builtin_names_1.translateMemberName)(name)); return declared?.readonly ? (0, catalog_1.message)('READONLY_ASSIGNMENT', { name }) : undefined; } /** `х -= 1`, `х += 1` on a non-string, … — operators that compute with the old value. */ isArithmeticAssignment(operator, targetType) { if (operator === '+=') return !this.isStringType(this.removeNullish(targetType)); return NUMERIC_BINARY_OPERATORS.has(operator.slice(0, -1)) && operator !== '=='; } inferBinaryType(binary) { const op = binary.operator; this.checkConstantOperand(binary); let left = this.inferExpressionType(binary.left); let right = this.inferRightOperand(binary); if (this.silent === 0) this.onBinaryTypes?.(binary, left, right); if (op === '??') { if (this.isAnyLike(left) || this.isAnyLike(right)) return UNKNOWN; return this.unionOf([this.removeNullish(left), right]); } if (this.computesWithOperands(op, left, right)) { left = this.checkNotNullish(binary.left, left); right = this.checkNotNullish(binary.right, right); } if (BOOLEAN_BINARY_OPERATORS.has(op)) return { kind: 'primitive', name: 'boolean' }; const bothNumeric = this.isNumericType(left) && this.isNumericType(right); if (NUMERIC_BINARY_OPERATORS.has(op)) { return bothNumeric ? { kind: 'primitive', name: 'number' } : UNKNOWN; } if (op === '+') { if (this.isStringType(left) || this.isStringType(right)) { return { kind: 'primitive', name: 'string' }; } return bothNumeric ? { kind: 'primitive', name: 'number' } : UNKNOWN; } return UNKNOWN; } /** `х !== холӣ && х.ном`: the right operand of `&&`/`||` only runs when the left one allows it. */ inferRightOperand(binary) { if (binary.operator !== '&&' && binary.operator !== '||') { return this.inferExpressionType(binary.right); } const facts = this.narrowingsFor(binary.left, binary.operator === '&&'); return this.withFacts(facts, () => this.inferExpressionType(binary.right)); } /** Operators that compute with their operands' values, so `холӣ`/`беқимат` are mistakes. */ computesWithOperands(op, left, right) { if (NUMERIC_BINARY_OPERATORS.has(op) || RELATIONAL_OPERATORS.has(op)) return true; return (op === '+' && !this.isStringType(this.removeNullish(left)) && !this.isStringType(this.removeNullish(right))); } inferUnaryType(unary) { if (unary.operator === '!') this.checkConstantCondition(unary.argument); const argument = this.inferExpressionType(unary.argument); switch (unary.operator) { case '!': case 'delete': return { kind: 'primitive', name: 'boolean' }; case 'typeof': return { kind: 'primitive', name: 'string' }; case '-': case '+': case '~': { // `-1` is the literal type `-1`, as in TypeScript if (unary.operator === '-' && argument.kind === 'literal') { if (typeof argument.value === 'number') return { kind: 'literal', value: -argument.value }; } const operand = this.checkNotNullish(unary.argument, argument); return this.isNumericType(operand) ? { kind: 'primitive', name: 'number' } : UNKNOWN; } default: return UNKNOWN; } } /** The test of `агар`, `то`, `барои` and `?:`. */ checkCondition(test) { this.checkConstantCondition(test); // `агар (х = 1)`: a learner who meant to compare const inner = (0, syntactic_conditions_1.skipOuterExpressions)(test); if (inner.type === 'AssignmentExpression' && inner.operator === '=') { this.addWarning(exports.TypeCheckErrorCode.AssignmentInCondition, (0, catalog_1.message)('ASSIGNMENT_IN_CONDITION'), inner.line, inner.column); } } /** * A condition its syntax decides, as TypeScript reports it since 5.6: always * truthy (`агар ([])`, TS2872) or always falsy (`то ("")`, TS2873). */ checkConstantCondition(test) { const semantics = (0, syntactic_conditions_1.truthySemantics)(test, this.isGlobalUndefined); if (semantics === 'sometimes') return; this.reportConstantCondition(test, semantics === 'always' ? 'CONSTANT_CONDITION.truthy' : 'CONSTANT_CONDITION.falsy'); } /** * The left operand of `??` when its syntax decides it, as TypeScript reports it * since 5.6: never nullish (`0 ?? 4`, TS2869) or always (`холӣ ?? 1`, TS2871). */ checkNullishOperand(left) { const operand = (0, syntactic_conditions_1.skipOuterExpressions)(left); const semantics = (0, syntactic_conditions_1.nullishSemantics)(operand, this.isGlobalUndefined); if (semantics === 'sometimes') return; this.reportConstantCondition(operand, semantics === 'never' ? 'CONSTANT_CONDITION.neverNullish' : 'CONSTANT_CONDITION.alwaysNullish'); } /** The left operand of `??`, `&&` and `||`, which TypeScript checks by its syntax. */ checkConstantOperand(binary) { if (binary.operator === '??') { this.checkNullishOperand(binary.left); } else if (binary.operator === '&&' || binary.operator === '||') { this.checkConstantCondition(binary.left); } } /** Reports a constant condition once, also when its expression is inferred again. */ reportConstantCondition(node, id) { if (this.silent > 0 || this.constantConditions.has(node)) return; this.constantConditions.add(node); this.addError(exports.TypeCheckErrorCode.ConstantCondition, (0, catalog_1.message)(id), node.line, node.column); } /** The operand of `++`/`--`: a number that is not nullish. */ inferNumericOperand(argument) { const type = this.checkNotNullish(argument, this.inferExpressionType(argument)); return this.isNumericType(type) ? { kind: 'primitive', name: 'number' } : UNKNOWN; } inferConditionalType(conditional, targetType) { this.checkCondition(conditional.test); this.inferExpressionType(conditional.test); const consequent = this.withFacts(this.narrowingsFor(conditional.test, true), () => this.inferExpressionType(conditional.consequent, targetType)); const alternate = this.withFacts(this.narrowingsFor(conditional.test, false), () => this.inferExpressionType(conditional.alternate, targetType)); if (consequent.kind === 'unknown' || alternate.kind === 'unknown') return UNKNOWN; if (this.isExactMatch(consequent, alternate)) return consequent; return { kind: 'union', types: [consequent, alternate] }; } // --------------------------------------------------------------------------- // Type assertions: `х чун Т`, `<Т>х`, `х чун собит`, `х бармесоё Т`, `х!` // --------------------------------------------------------------------------- /** The expression an assertion (or several) wraps. */ skipAssertions(expression) { let current = expression; while (ASSERTION_TYPES.has(current.type)) { current = current.expression; } return current; } /** * `х чун Т` / `<Т>х` has type `Т` (in strict mode `х чун Г` removes * `холӣ`). As in TypeScript, it is an error only when neither type is * assignable to the other. */ inferAssertionType(assertion) { if (assertion.isConst || !assertion.typeAnnotation) { return this.inferConstAssertionType(assertion); } const target = this.resolveTypeNode(assertion.typeAnnotation); const source = this.inferExpressionType(assertion.expression, target); if (!this.isComparable(source, target)) { const sourceName = this.typeToString(this.widenLiterals(source)); this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.conversion', { source: sourceName, target: this.typeToString(target), }), assertion.line, assertion.column); } return target; } /** `type` with its literal types widened, as an assertion compares its operand (`1` → `рақам`). */ widenLiterals(type) { switch (type.kind) { case 'literal': return this.getBaseType(type); case 'union': return this.unionOf(type.types.map(t => this.widenLiterals(t))); case 'tuple': return { ...type, types: type.types?.map(t => this.widenLiterals(t)) }; case 'array': return { ...type, elementType: this.widenLiterals(type.elementType) }; case 'object': { const properties = new Map(); for (const [key, prop] of type.properties) { properties.set(key, { ...prop, type: this.widenLiterals(prop.type) }); } return { ...type, properties }; } default: return type; } } /** * TypeScript's comparability of assertions: some member of one type * (literal types widened or not) is assignable to some member of the other. */ isComparable(source, target) { if (this.isAnyLike(source) || this.isAnyLike(target)) return true; const isNever = (t) => t.kind === 'primitive' && t.name === 'never'; const sources = [ ...this.unionMembers(source), ...this.unionMembers(this.widenLiterals(source)), ]; const targets = this.unionMembers(target); return sources.some(s => targets.some(t => isNever(s) || isNever(t) || this.isAssignable(s, t) || this.isAssignable(t, s) || this.hasRequiredMembers(s, t) || this.hasRequiredMembers(t, s))); } /** `[1] чун { length: рақам }`: a built-in value has every required member of an object type. */ hasRequiredMembers(builtin, objectType) { if (objectType.kind !== 'object' && objectType.kind !== 'interface') return false; const members = this.builtinMembersOf(builtin) ?? (builtin.kind === 'function' ? exports.BUILTIN_MEMBERS.function : undefined); if (!members) return false; return [...this.getAllProperties(objectType)].every(([name, prop]) => prop.optional || members.has((0, builtin_names_1.translateMemberName)(name))); } /** * `х чун собит`: literals keep their literal types, array literals become * readonly tuples, and none of them is widened when bound. */ inferConstAssertionType(assertion) { const expression = assertion.expression; if (!this.isConstAssertionOperand(expression)) { this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.constAssertion'), assertion.line, assertion.column); return this.inferExpressionType(expression); } return this.constType(expression); } /** Operands TypeScript accepts in `as const` (a member expression may name an enum member). */ isConstAssertionOperand(expression) { switch (expression.type) { case 'Literal': return expression.value !== null; case 'TemplateLiteral': case 'ArrayExpression': case 'ObjectExpression': case 'MemberExpression': return true; case 'UnaryExpression': { const unary = expression; return ((unary.operator === '-' || unary.operator === '+') && unary.argument.type === 'Literal' && typeof unary.argument.value === 'number'); } default: return false; } } constType(expression) { switch (expression.type) { case 'ArrayExpression': { const elements = expression.elements; if (elements.some(element => !element || element.type === 'SpreadElement')) { return { ...this.inferExpressionType(expression), constant: true }; } return { kind: 'tuple', types: elements.map(element => this.constType(element)), constant: true, readonly: true, }; } case 'ObjectExpression': { const objExpr = expression; if (objExpr.properties.some(p => p.type === 'SpreadElement' || p.computed)) { return this.inferExpressionType(expression); } const properties = new Map(); for (const prop of objExpr.properties) { const value = prop.value; properties.set(this.propertyKeyName(prop.key), { type: this.constType(value), optional: false, }); } return { kind: 'object', properties, fromLiteral: true, constant: true }; } case 'UnaryExpression': { const unary = expression; const value = unary.argument.value; if (unary.argument.type === 'Literal' && typeof value === 'number' && !/n$/.test(unary.argument.raw)) { return { kind: 'literal', value: unary.operator === '-' ? -value : value, constant: true, }; } return this.inferExpressionType(expression); } default: { const type = this.inferExpressionType(expression); return type.kind === 'literal' ? { ...type, constant: true } : type; } } } /** * `х бармесоё Т`: `х` must be assignable to `Т` (object literals without * unknown keys, as for `тағ х: Т = …`) and keeps its own type. */ inferSatisfiesType(node) { const target = this.resolveTypeNode(node.typeAnnotation); const type = this.inferExpressionType(node.expression, target); this.checkAssignable(node.expression, type, target, (source, expected) => this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.satisfies', { source, expected }), node.expression.line, node.expression.column)); return type; } isNumericType(type) { return ((type.kind === 'primitive' && type.name === 'number') || (type.kind === 'literal' && typeof type.value === 'number')); } isStringType(type) { return ((type.kind === 'primitive' && type.name === 'string') || (type.kind === 'literal' && typeof type.value === 'string')); } isPromiseType(type) { return type.kind === 'generic' && type.name === 'Promise'; } unwrapPromise(type) { if (this.isPromiseType(type)) return type.typeParameters?.[0] ?? UNKNOWN; return type; } inferCallType(callExpr) { const callee = callExpr.callee; if (this.isBuiltinReference(callee) && (0, builtin_globals_1.isNotCallableBuiltin)(callee.name)) { this.addError(exports.TypeCheckErrorCode.NotCallable, (0, catalog_1.message)('NOT_CALLABLE', { name: callee.name }), callee.line, callee.column); } // Route identifiers through inferIdentifierType so undefined callees // produce a single UndefinedIdentifier diagnostic. const functionType = this.callableType(this.inferExpressionType(callee)); this.calleeTypes.set(callExpr, functionType); if (functionType.kind === 'function' && !this.isOptionalChain(callExpr)) { if (functionType.overloads) return this.inferOverloadedCall(callExpr, functionType); this.validateCallArguments(callExpr, functionType); return functionType.returnType; } // Still evaluate args so nested undefined identifiers are flagged. callExpr.arguments.forEach(arg => this.inferExpressionType(arg)); return UNKNOWN; } /** * The function type a call of a value of `type` is checked against: its * call signatures (`интерфейс Ф { (х: рақам): сатр; }`, overloads when * there are several) or the type itself. */ callableType(type) { const signatures = type.kind === 'function' ? undefined : type.callSignatures; if (!signatures || signatures.length === 0) return type; return signatures.length === 1 ? signatures[0] : { ...signatures[0], overloads: signatures }; } /** What `нав` of a value of `type` creates, by its construct signature. */ constructedType(type) { const signature = type?.constructSignatures?.[0]; return signature?.returnType; } /** * A call of an overloaded function: the first overload whose parameters fit * the arguments (their count and types) decides the result; when none fits, * that is TypeScript's "No overload matches this call". */ inferOverloadedCall(callExpr, functionType) { const overloads = functionType.overloads; const match = overloads.find(overload => this.overloadAccepts(callExpr, overload)); if (match) { this.validateCallArguments(callExpr, match); return match.returnType; } callExpr.arguments.forEach(arg => this.inferExpressionType(arg)); const signatures = overloads.map(overload => this.functionTypeToString(overload)).join('; '); this.addError(exports.TypeCheckErrorCode.NoMatchingOverload, (0, catalog_1.message)('NO_MATCHING_OVERLOAD', { function: functionType.name, overloads: signatures }), callExpr.line, callExpr.column); return UNKNOWN; } /** Whether the arguments of `callExpr` fit `overload`, judged without reporting anything. */ overloadAccepts(callExpr, overload) { const paramTypes = overload.paramTypes; const args = callExpr.arguments; const shape = this.parameterShape(overload); const spreadIndex = args.findIndex(arg => arg.type === 'SpreadElement'); if (spreadIndex === -1 && (args.length < shape.requiredCount || (!shape.hasRest && args.length > shape.fixedCount))) { return false; } return args.every((arg, i) => { if (spreadIndex !== -1 && i >= spreadIndex) return true; const declared = i < shape.fixedCount ? paramTypes[i] : shape.restElementType; if (!declared) return true; const paramType = i < shape.fixedCount && shape.optional[i] ? this.optionalType(declared) : declared; this.silent++; try { const argType = this.inferExpressionType(arg, paramType); return this.isAssignableFrom(arg, argType, paramType); } finally { this.silent--; } }); } /** Parameter counts of a function type: fixed, required, optional ones and the rest element. */ parameterShape(functionType) { const paramTypes = functionType.paramTypes; const hasRest = Boolean(functionType.hasRestParam); const fixedCount = hasRest ? paramTypes.length - 1 : paramTypes.length; const optional = functionType.paramOptional; const requiredCount = optional.slice(0, fixedCount).filter(o => !o).length; const restType = hasRest ? paramTypes[paramTypes.length - 1] : undefined; const restElementType = restType?.kind === 'array' ? restType.elementType : undefined; return { hasRest, fixedCount, requiredCount, optional, restElementType }; } validateCallArguments(callExpr, functionType) { const paramTypes = functionType.paramTypes; if (!paramTypes) { // Still walk args so nested undefined identifiers are detected. callExpr.arguments.forEach(arg => this.inferExpressionType(arg)); return; } const args = callExpr.arguments; const spreadIndex = args.findIndex(arg => arg.type === 'SpreadElement'); const { hasRest, fixedCount, optional, requiredCount } = this.parameterShape(functionType); if (spreadIndex === -1 && (args.length < requiredCount || (!hasRest && args.length > fixedCount))) { this.addError(exports.TypeCheckErrorCode.ArgumentCountMismatch, (0, catalog_1.message)('ARGUMENT_COUNT_MISMATCH', { function: functionType.name, min: requiredCount, max: hasRest ? undefined : fixedCount, got: args.length, }), callExpr.line, callExpr.column); } const restType = hasRest ? paramTypes[paramTypes.length - 1] : undefined; const restElementType = restType?.kind === 'array' ? restType.elementType : undefined; args.forEach((argNode, i) => { // Positions after a spread argument are unknown const declaredType = spreadIndex !== -1 && i >= spreadIndex ? undefined : i < fixedCount ? paramTypes[i] : restElementType; // An optional or defaulted parameter also accepts `беқимат` const paramType = declaredType && i < fixedCount && optional[i] ? this.optionalType(declaredType) : declaredType; const argType = this.inferExpressionType(argNode, paramType); if (!paramType) return; this.checkAssignable(argNode, argType, paramType, (source, target) => this.addError(exports.TypeCheckErrorCode.ArgumentTypeMismatch, (0, catalog_1.message)('ARGUMENT_TYPE_MISMATCH', { index: i + 1, function: functionType.name, expected: target, got: source, }), argNode.line, argNode.column)); }); } /** `тег\`…\``: the tag is called, so the result is what it returns. */ inferTaggedTemplateType(tagged) { const tagType = this.checkNotNullish(tagged.tag, this.inferExpressionType(tagged.tag)); tagged.quasi.expressions.forEach(part => this.inferExpressionType(part)); return tagType.kind === 'function' ? tagType.returnType : UNKNOWN; } inferNewExpressionType(newExpr) { // Walk args so nested undefined identifiers are flagged newExpr.arguments.forEach(arg => this.inferExpressionType(arg)); if (newExpr.callee.type === 'Identifier') { const className = newExpr.callee.name; const builtin = this.builtinInstanceType(className, newExpr); if (builtin) return builtin; const classType = this.lookup(className); if (classType && classType.kind === 'class') { if (classType.abstract) { this.addError(exports.TypeCheckErrorCode.AbstractInstantiation, (0, catalog_1.message)('ABSTRACT_INSTANTIATION', { class: className }), newExpr.line, newExpr.column); } // Return the actual class type with all its properties and baseType return classType; } // A value of a constructor type: `нав (а: рақам) => Т` if (classType?.kind === 'constructor') return classType.returnType; // A value of a type with a construct signature: `{ нав (а: рақам): Т }` const constructed = this.constructedType(classType); if (constructed) return constructed; } else { // `нав (синф { … })()` constructs an instance of the class const calleeType = this.inferExpressionType(newExpr.callee); if (calleeType.kind === 'class') return calleeType; const constructed = this.constructedType(calleeType); if (constructed) return constructed; } return UNKNOWN; } /** Instances of built-in classes: `нав Map<сатр, рақам>()`, `нав Set()`, `нав RegExp(…)`. */ builtinInstanceType(className, newExpr) { const typeArguments = (newExpr.typeArguments ?? []).map(t => this.resolveTypeNode(t)); const any = { kind: 'primitive', name: 'any' }; if (className === 'Map') { return { kind: 'generic', name: 'Map', typeParameters: typeArguments.length === 2 ? typeArguments : [any, any], }; } if (className === 'Set') { return { kind: 'generic', name: 'Set', typeParameters: typeArguments.length === 1 ? typeArguments : [any], }; } if (className === 'RegExp' && !this.lookup(className)) return REGEXP_TYPE; return undefined; } // --------------------------------------------------------------------------- // Narrowing // // References (`х`, `ин.сар.пас`) get a narrower type than their declared one // after checks such as `агар (х !== холӣ)`, early exits (`агар (!х) бозгашт;`) // and assignments. Facts are keyed by `referenceKey` and dropped when the // reference (or an object on its path) is assigned. // --------------------------------------------------------------------------- bindingKey(scopeIndex, name) { return `${this.scopeIds[scopeIndex]}:${name}`; } /** Key identifying a narrowable reference: a variable, `ин`, or a member path on them. */ referenceKey(expression) { switch (expression.type) { case 'Identifier': { const name = expression.name; const index = this.scopeIndexOf(name); return index === -1 ? undefined : this.bindingKey(index, name); } case 'ThisExpression': return 'ин'; case 'NonNullExpression': // `х!` refers to `х`, as in TypeScript return this.referenceKey(expression.expression); case 'MemberExpression': { const member = expression; const property = member.computed ? undefined : this.memberPropertyName(member); if (!property) return undefined; const objectKey = this.referenceKey(member.object); return objectKey && `${objectKey}.${property.name}`; } default: return undefined; } } /** Forgets what is known about `key` and every member path below it. */ invalidate(key) { if (!key) return; for (const narrowedKey of [...this.narrowed.keys()]) { if (narrowedKey === key || narrowedKey.startsWith(`${key}.`)) { this.narrowed.delete(narrowedKey); } } } applyFacts(facts) { facts.forEach((type, key) => this.narrowed.set(key, type)); } /** Runs `body` with `facts` added; narrowing changes made by `body` are discarded. */ withFacts(facts, body) { const saved = this.narrowed; this.narrowed = new Map(saved); this.applyFacts(facts); try { return body(); } finally { this.narrowed = saved; } } /** Infers a type without reporting diagnostics (they were reported on the first pass). */ quietType(expression) { this.silent++; try { return this.inferExpressionType(expression); } finally { this.silent--; } } /** What is known when `test` evaluates to `assumeTrue`. */ narrowingsFor(test, assumeTrue) { if (test.type === 'UnaryExpression' && test.operator === '!') { return this.narrowingsFor(test.argument, !assumeTrue); } if (test.type === 'NonNullExpression') { // `агар (х!)` tests `х` itself return this.narrowingsFor(test.expression, assumeTrue); } if (test.type === 'BinaryExpression') { const binary = test; switch (binary.operator) { case '&&': return assumeTrue ? this.sequenceFacts(binary.left, true, binary.right, true) : this.joinFacts(this.narrowingsFor(binary.left, false), this.sequenceFacts(binary.left, true, binary.right, false)); case '||': return assumeTrue ? this.joinFacts(this.narrowingsFor(binary.left, true), this.sequenceFacts(binary.left, false, binary.right, true)) : this.sequenceFacts(binary.left, false, binary.right, false); case '===': case '!==': case '==': case '!=': return this.equalityFacts(binary, assumeTrue); case 'instanceof': return assumeTrue ? this.instanceofFacts(binary) : new Map(); default: return new Map(); } } return this.truthinessFacts(test, assumeTrue); } /** Facts of `first` being `firstValue` and then `second` being `secondValue`. */ sequenceFacts(first, firstValue, second, secondValue) { const firstFacts = this.narrowingsFor(first, firstValue); const secondFacts = this.withFacts(firstFacts, () => this.narrowingsFor(second, secondValue)); return new Map([...firstFacts, ...secondFacts]); } /** Facts that hold on either of two paths. */ joinFacts(a, b) { const joined = new Map(); a.forEach((type, key) => { const other = b.get(key); if (other) joined.set(key, this.unionOf([type, other])); }); return joined; } truthinessFacts(expression, assumeTrue) { // A call is no reference, but a call of a type predicate narrows its argument if (expression.type === 'CallExpression') { return this.predicateFacts(expression, assumeTrue); } const key = this.referenceKey(expression); if (!key || !assumeTrue) return new Map(); const current = this.quietType(expression); if (this.isAnyLike(current) || this.nullishNames(current).length === 0) return new Map(); return new Map([[key, this.removeNullish(current)]]); } /** `агар (сатрАст(х))` with `сатрАст(х: ношинос): х аст сатр`: `х` is a сатр when it returns true. */ predicateFacts(call, assumeTrue) { const predicate = this.calleePredicate(call); if (!predicate || predicate.asserts) return new Map(); return this.predicateSubjectFacts(call, predicate, assumeTrue); } /** After the statement `тасдиқКун(х);` with `тасдиқКун(ш: ҳар): тасдиқ ш [аст Т]`. */ assertionFacts(call) { const predicate = this.calleePredicate(call); if (!predicate?.asserts) return new Map(); if (predicate.type) return this.predicateSubjectFacts(call, predicate, true); // `тасдиқ ш`: the argument is truthy, so it narrows like a condition const subject = this.predicateSubject(call, predicate); return subject ? this.narrowingsFor(subject, true) : new Map(); } calleePredicate(call) { if (this.isOptionalChain(call)) return undefined; const calleeType = this.calleeTypes.get(call) ?? this.quietType(call.callee); return calleeType.kind === 'function' ? calleeType.predicate : undefined; } /** The argument a predicate is about, or the receiver for `ин аст Т`. */ predicateSubject(call, predicate) { if (predicate.parameter === 'this') { const callee = call.callee; return callee.type === 'MemberExpression' ? callee.object : undefined; } const argument = call.arguments[predicate.parameter]; return argument?.type === 'SpreadElement' ? undefined : argument; } predicateSubjectFacts(call, predicate, assumeTrue) { const subject = this.predicateSubject(call, predicate); const key = subject && this.referenceKey(subject); if (!subject || !key || !predicate.type) return new Map(); const current = this.quietType(subject); const narrowed = assumeTrue ? this.narrowTo(current, predicate.type) : this.narrowExcluding(current, predicate.type); return narrowed ? new Map([[key, narrowed]]) : new Map(); } /** `current` where a predicate says it is a `target`: the union members that are, else `target`. */ narrowTo(current, target) { if (this.isAnyLike(current)) return target; const kept = this.unionMembers(current).filter(t => this.isAssignable(t, target)); if (kept.length > 0) return this.unionOf(kept); // `ин аст { қимат: рақам }` on a class instance: both, as in TypeScript if (['class', 'interface', 'object'].includes(current.kind)) { return { kind: 'intersection', types: [current, target] }; } return target; } /** `current` where a predicate says it is no `target`: the other union members. */ narrowExcluding(current, target) { if (this.isAnyLike(current)) return undefined; const members = this.unionMembers(current); const rest = members.filter(t => !this.isAssignable(t, target)); return rest.length > 0 && rest.length < members.length ? this.unionOf(rest) : undefined; } equalityFacts(binary, assumeTrue) { const equal = (binary.operator === '===' || binary.operator === '==') === assumeTrue; const loose = binary.operator === '==' || binary.operator === '!='; for (const [typeofSide, literalSide] of [ [binary.left, binary.right], [binary.right, binary.left], ]) { if (this.isTypeofExpression(typeofSide) && literalSide.type === 'Literal') { return this.typeofFacts(typeofSide, literalSide, equal); } } const comparison = this.nullComparison(binary); const key = comparison && this.referenceKey(comparison.reference); if (!comparison || !key) return new Map(); const { reference, nullish } = comparison; const current = this.quietType(reference); if (this.isAnyLike(current)) return new Map(); const names = loose ? ['null', 'undefined'] : [nullish]; if (equal) { const present = this.nullishNames(current).filter(name => names.includes(name)); const kept = present.length > 0 ? present : [nullish]; return new Map([[key, this.unionOf(kept.map(name => this.nullishType(name)))]]); } const rest = this.unionMembers(current).filter(t => !(t.kind === 'primitive' && names.includes(t.name))); return new Map([[key, rest.length > 0 ? this.unionOf(rest) : UNKNOWN]]); } /** The reference compared in `х === холӣ` / `беқимат !== х`, and which value it is compared with. */ nullComparison(binary) { const right = this.nullishLiteral(binary.right); if (right) return { reference: binary.left, nullish: right }; const left = this.nullishLiteral(binary.left); return left ? { reference: binary.right, nullish: left } : undefined; } isTypeofExpression(expression) { return (expression.type === 'UnaryExpression' && expression.operator === 'typeof'); } /** `навъи х === "string"` keeps the union members of that JavaScript type. */ typeofFacts(typeofExpr, literal, equal) { const key = this.referenceKey(typeofExpr.argument); if (!key || typeof literal.value !== 'string') return new Map(); const current = this.quietType(typeofExpr.argument); if (current.kind !== 'union' || this.isAnyLike(current)) return new Map(); const members = this.unionMembers(current); const kept = members.filter(t => (this.typeofName(t) === literal.value) === equal); if (kept.length === 0 || kept.length === members.length) return new Map(); return new Map([[key, this.unionOf(kept)]]); } /** The `typeof` result of values of a type, when one is determined. */ typeofName(type) { const base = this.getBaseType(type.kind === 'unique' ? type.baseType : type); if (base.kind === 'primitive') { if (base.name === 'null') return 'object'; return ['string', 'number', 'boolean', 'undefined', 'symbol'].includes(base.name) ? base.name : undefined; } if (type.kind === 'function' || type.kind === 'constructor') return 'function'; return ['object', 'interface', 'array', 'tuple', 'generic'].includes(type.kind) ? 'object' : undefined; } instanceofFacts(binary) { const key = this.referenceKey(binary.left); if (!key || binary.right.type !== 'Identifier') return new Map(); const classType = this.lookup(binary.right.name); return classType?.kind === 'class' ? new Map([[key, classType]]) : new Map(); } /** `холӣ` → 'null', `беқимат` → 'undefined', anything else → undefined. */ nullishLiteral(expression) { if (expression.type === 'Literal' && expression.value === null) return 'null'; if (expression.type === 'Identifier') { const name = expression.name; if ((name === 'беқимат' || name === 'undefined') && !this.lookup(name)) return 'undefined'; } return undefined; } /** * Type of a reference right after `= value`: a value that can't be * `холӣ`/`беқимат` removes them from the declared type, and `холӣ` itself * narrows to `холӣ`. Returns undefined when the declared type applies. */ assignmentNarrowing(declared, assigned) { if (this.isAnyLike(declared) || this.isAnyLike(assigned)) return undefined; const declaredNullish = this.nullishNames(declared); const assignedNullish = this.nullishNames(assigned); if (assignedNullish.length === 0) { return declaredNullish.length > 0 ? this.removeNullish(declared) : undefined; } const onlyNullish = this.unionMembers(assigned).every(t => this.isNullishType(t)); return onlyNullish ? assigned : undefined; } narrowOnAssignment(target, declared, assigned) { const key = this.referenceKey(target); if (!key) return; this.invalidate(key); const narrowed = this.assignmentNarrowing(declared, assigned); if (narrowed) this.narrowed.set(key, narrowed); } /** Facts after two branches meet: a reference keeps only what both agree on. */ joinNarrowed(a, b) { return this.joinFacts(a, b); } /** Whether the variable a reference key starts with can't change after being narrowed. */ isNeverReassigned(key) { if (key.includes('.')) return false; if (this.constKeys.has(key)) return true; return !this.reassignedNames.has(key.slice(key.indexOf(':') + 1)); } collectReassignedNames(program) { const names = new Set(); const addTargets = (target) => this.forEachNode(target, node => { if (node.type === 'Identifier') names.add(node.name); }); this.forEachNode(program, node => { if (node.type === 'AssignmentExpression') { const left = this.skipAssertions(node.left); if (left.type !== 'MemberExpression') addTargets(left); } else if (node.type === 'UpdateExpression') { addTargets(node.argument); } else if (node.type === 'ForInStatement' || node.type === 'ForOfStatement') { const left = node.left; if (left.type !== 'VariableDeclaration') addTargets(left); } }); return names; } /** Forgets facts about every reference assigned somewhere inside `nodes` (loop bodies, …). */ invalidateAssignedIn(...nodes) { const invalidateTarget = (target) => { this.forEachNode(target, node => { if (node.type === 'Identifier' || node.type === 'MemberExpression') { this.invalidate(this.referenceKey(node)); } }); }; for (const root of nodes) { this.forEachNode(root, node => { if (node.type === 'AssignmentExpression') { invalidateTarget(node.left); } else if (node.type === 'ForInStatement' || node.type === 'ForOfStatement') { const left = node.left; if (left.type !== 'VariableDeclaration') invalidateTarget(left); } }); } } /** Calls `visit` for every AST node below `node` (type annotations excluded). */ forEachNode(node, visit) { if (!node || typeof node !== 'object') return; if (Array.isArray(node)) { node.forEach(child => this.forEachNode(child, visit)); return; } const record = node; if (typeof record.type === 'string') visit(record); for (const [key, value] of Object.entries(record)) { if (['typeAnnotation', 'returnType', 'typeArguments', 'typeParameters'].includes(key)) { continue; } if (value && typeof value === 'object') this.forEachNode(value, visit); } } /** Whether `body` contains a `шикастан` that can leave the loop owning `body`. */ containsLoopExit(body) { const visit = (node, nested) => { if (!node || typeof node !== 'object') return false; if (Array.isArray(node)) return node.some(child => visit(child, nested)); const record = node; const type = String(record.type ?? ''); // An unlabelled `шикастан` in a nested loop or `интихоб` only leaves that one if (type === 'BreakStatement') return !nested || Boolean(record.label); if (/Function|ClassDeclaration/.test(type)) return false; const nestsJump = nested || JUMP_TARGETS.has(type); return Object.values(record).some(value => visit(value, nestsJump)); }; return visit(body, false); } /** Whether `body` has a `давом` that may continue the loop owning `body`. */ containsLoopContinue(body) { const visit = (node, nested) => { if (!node || typeof node !== 'object') return false; if (Array.isArray(node)) return node.some(child => visit(child, nested)); const record = node; const type = String(record.type ?? ''); // An unlabelled `давом` in a nested loop continues that one if (type === 'ContinueStatement') return !nested || Boolean(record.label); if (/Function|ClassDeclaration/.test(type)) return false; const nestsLoop = nested || (JUMP_TARGETS.has(type) && type !== 'SwitchStatement'); return Object.values(record).some(value => visit(value, nestsLoop)); }; return visit(body, false); } /** Whether `body` has a `шикастан label;`. */ breaksTo(label, body) { let found = false; this.forEachNode(body, node => { const jump = node; if (jump.type === 'BreakStatement' && jump.label?.name === label) found = true; }); return found; } /** Whether control never continues after `statement` (it returns, throws, breaks or continues). */ alwaysExits(statement) { if (!statement) return false; switch (statement.type) { case 'ReturnStatement': case 'ThrowStatement': case 'BreakStatement': case 'ContinueStatement': return true; case 'BlockStatement': return statement.body.some(s => this.alwaysExits(s)); case 'LabeledStatement': return this.labeledAlwaysExits(statement); case 'IfStatement': { const ifStatement = statement; return this.alwaysExits(ifStatement.consequent) && this.alwaysExits(ifStatement.alternate); } case 'TryStatement': { const tryStatement = statement; if (tryStatement.finalizer && this.alwaysExits(tryStatement.finalizer)) return true; return (this.alwaysExits(tryStatement.block) && (!tryStatement.handler || this.alwaysExits(tryStatement.handler.body))); } default: return false; } } /** `л: { … }` exits when its body does, unless a `шикастан л;` continues after it. */ labeledAlwaysExits(statement) { return this.alwaysExits(statement.body) && !this.breaksTo(statement.label.name, statement.body); } // --------------------------------------------------------------------------- // Nullability // --------------------------------------------------------------------------- /** Members of a union (nested unions flattened); a single type for anything else. */ unionMembers(type) { if (type.kind !== 'union' || !type.types) return [type]; return type.types.flatMap(t => this.unionMembers(t)); } /** Union of `types` without duplicates; a single type stays itself. */ unionOf(types) { // Members that print the same are the same type const byName = new Map(); for (const member of types.flatMap(t => this.unionMembers(t))) { const name = this.typeToString(member); if (!byName.has(name)) byName.set(name, member); } const members = [...byName.values()]; return members.length === 1 ? members[0] : { kind: 'union', types: members }; } isNullishType(type) { return type.kind === 'primitive' && (type.name === 'null' || type.name === 'undefined'); } nullishType(name) { return name === 'null' ? NULL_TYPE : UNDEFINED_TYPE; } /** Which of 'null' / 'undefined' the values of `type` may be. */ nullishNames(type) { const names = this.unionMembers(type) .filter(t => this.isNullishType(t)) .map(t => t.name); return [...new Set(names)]; } removeNullish(type) { const rest = this.unionMembers(type).filter(t => !this.isNullishType(t)); if (rest.length === 0) return UNKNOWN; return rest.length === 1 ? rest[0] : { kind: 'union', types: rest }; } /** Types that turn checking off: unresolved, `ҳар`, `ношинос`, or unions containing them. */ isAnyLike(type) { return this.unionMembers(type).some(t => t.kind === 'unknown' || (t.kind === 'primitive' && ['any', 'unknown'].includes(t.name))); } /** `type | беқимат`, or unknown when `type` itself is unknown. */ orUndefined(type) { return this.isAnyLike(type) ? UNKNOWN : this.unionOf([type, UNDEFINED_TYPE]); } /** Type of an optional slot (`а?: Т`): `Т | беқимат` in strict mode. */ optionalType(type) { return this.strict ? this.orUndefined(type) : type; } /** * In strict mode reports a value that may be `холӣ`/`беқимат` where it is * dereferenced or computed with; returns the type without them. */ checkNotNullish(expression, type) { const nullish = this.nullishNames(type); if (nullish.length === 0) return type; if (this.strict && !this.isAnyLike(type)) { this.addError(exports.TypeCheckErrorCode.PossiblyNull, (0, catalog_1.message)('POSSIBLY_NULL', { reference: this.referencePath(expression), values: nullish.map(name => this.mapPrimitiveToTajik(name)), }), expression.line, expression.column); } return this.removeNullish(type); } /** `х`, `ин.сар` for references; nothing for any other expression. */ referencePath(expression) { const path = (e) => { if (e.type === 'Identifier') return e.name; if (e.type === 'ThisExpression') return 'ин'; if (e.type === 'NonNullExpression') return path(e.expression); if (e.type === 'MemberExpression' && !e.computed) { const member = e; const objectPath = path(member.object); const property = this.memberPropertyName(member); return objectPath && property.name ? `${objectPath}.${property.name}` : undefined; } return undefined; }; return path(expression); } // --------------------------------------------------------------------------- // Assignability // --------------------------------------------------------------------------- /** * Reports through `report` when `sourceType` (the type of `sourceExpr`) is * not assignable to `targetType`; otherwise checks fresh object literals for * properties the target doesn't declare. */ checkAssignable(sourceExpr, sourceType, targetType, report) { if (!this.isAssignableFrom(sourceExpr, sourceType, targetType)) { report(this.typeToString(sourceType), this.typeToString(targetType)); return; } this.checkExcessProperties(sourceExpr, targetType); } /** Whether the value of `sourceExpr` (of type `sourceType`) may be assigned to `targetType`. */ isAssignableFrom(sourceExpr, sourceType, targetType) { // Control flow isn't tracked, so a union-typed reference may already be // narrowed (`агар (навъи х === "string") бозгашт х;`): accept it when any // member fits. const narrowable = sourceType.kind === 'union' && (sourceExpr.type === 'Identifier' || sourceExpr.type === 'MemberExpression'); return narrowable ? this.isNarrowableUnionAssignable(sourceType, targetType) : this.isAssignable(sourceType, targetType); } /** * A union-typed reference fits when one member does. In strict mode * `холӣ`/`беқимат` members must fit as well: null checks *are* tracked. */ isNarrowableUnionAssignable(sourceType, targetType) { if (!this.strict) return sourceType.types.some(t => this.isAssignable(t, targetType)); const members = this.unionMembers(sourceType); const nullish = members.filter(t => this.isNullishType(t)); const rest = members.filter(t => !this.isNullishType(t)); return (nullish.every(t => this.isAssignable(t, targetType)) && (rest.length === 0 || rest.some(t => this.isAssignable(t, targetType)))); } checkExcessProperties(expr, targetType) { if (expr.type === 'ArrayExpression' && targetType.kind === 'array') { for (const element of expr.elements) { if (element) this.checkExcessProperties(element, targetType.elementType); } return; } if (expr.type !== 'ObjectExpression') return; if (targetType.kind !== 'interface' && targetType.kind !== 'object') return; // An index signature accepts any key if (targetType.indexType || targetType.open) return; const objExpr = expr; if (objExpr.properties.some(p => p.type === 'SpreadElement' || p.computed)) return; this.checkObjectLiteralKeys(objExpr, targetType); } checkObjectLiteralKeys(objExpr, targetType) { const targetProperties = this.getAllProperties(targetType); // Literals with a spread are not checked (`checkExcessProperties`) for (const prop of objExpr.properties) { const keyName = this.propertyKeyName(prop.key); const targetProp = targetProperties.get(keyName); if (!targetProp) { this.addError(exports.TypeCheckErrorCode.TypeMismatch, (0, catalog_1.message)('TYPE_NOT_ASSIGNABLE.excessProperty', { property: keyName, target: this.typeToString(targetType), }), prop.line, prop.column); } else if (prop.value) { this.checkExcessProperties(prop.value, targetProp.type); } } } isLiteralAssignableToPrimitive(source, target) { if (source.kind !== 'literal' || target.kind !== 'primitive') { return false; } return TypeChecker.literalBaseName(source) === target.name; } isStandardTypeAssignable(source, target) { return (this.isArrayAssignable(source, target) || this.isTupleAssignable(source, target) || this.isTupleToArrayAssignable(source, target) || this.isUnionAssignable(source, target) || this.isIntersectionAssignable(source, target)); } isStructuralTypeAssignable(source, target) { return (this.isInterfaceAssignable(source, target) || this.isClassAssignable(source, target) || this.isUniqueAssignable(source, target) || // A class (or a function) is a value of a constructor type (target.kind === 'constructor' && ['class', 'constructor', 'function'].includes(source.kind)) || // A value with call signatures is a function (target.kind === 'function' && Boolean(source.callSignatures?.length)) || (target.kind === 'constructor' && Boolean(source.constructSignatures?.length))); } /** * Top-type rules: anything goes to `ҳар`/`ношинос`, `ҳар` goes anywhere, * and unresolved types are never reported. Without strict mode * `холӣ`/`беқимат` are accepted everywhere, like TypeScript without * `strictNullChecks`; in strict mode only by types that include them * (and `беқимат` by `беджавоб`). */ isTopTypeAssignable(source, target) { if (source === target || source.kind === 'unknown' || target.kind === 'unknown') return true; if (target.kind === 'primitive' && (target.name === 'any' || target.name === 'unknown')) { return true; } if (source.kind === 'primitive') { if (source.name === 'any') return true; if (source.name === 'null' || source.name === 'undefined') { if (!this.strict) return true; return source.name === 'undefined' && target.kind === 'primitive' && target.name === 'void'; } } return false; } isObjectTargetAssignable(source, target) { if (target.kind !== 'primitive' || target.name !== 'object') return false; return ['object', 'interface', 'class', 'array', 'tuple', 'generic', 'function'].includes(source.kind); } isAssignable(source, target) { if (this.isTopTypeAssignable(source, target)) { return true; } // `ин` not bound to a receiver is not checked if (source.kind === 'this' || target.kind === 'this') { return true; } if (this.isExactMatch(source, target)) { return true; } if (this.isObjectTargetAssignable(source, target)) { return true; } // Function signatures aren't compared (no variance checking) if (source.kind === 'function' && target.kind === 'function') { return true; } if (this.isLiteralAssignableToPrimitive(source, target)) { return true; } if (this.isStandardTypeAssignable(source, target)) { return true; } return this.isStructuralTypeAssignable(source, target); } isExactMatch(source, target) { // Check for literal type match if (source.kind === 'literal' && target.kind === 'literal') { return source.value === target.value; } // Check for generic type match (Map, Set) if (source.kind === 'generic' && target.kind === 'generic') { if (source.name !== target.name) { return false; } if (!source.typeParameters || !target.typeParameters) { return source.typeParameters === target.typeParameters; } if (source.typeParameters.length !== target.typeParameters.length) { return false; } // For now, we consider generics with 'any' type parameters compatible // Full variance checking can be added later return true; } // Primitives match by name; classes and interfaces by declared name. // Structured types (arrays, objects, unions, …) have no name to compare. if (!['primitive', 'class', 'interface'].includes(source.kind) || !source.name) { return false; } return source.kind === target.kind && source.name === target.name; } isArrayAssignable(source, target) { if (source.kind !== 'array' || target.kind !== 'array') { return false; } // A `танҳохонӣ` array can't be used where it could be changed if (source.readonly && !target.readonly) return false; return this.isAssignable(source.elementType, target.elementType); } isTupleAssignable(source, target) { if (source.kind !== 'tuple' || target.kind !== 'tuple' || !source.types || !target.types) { return false; } if (source.readonly && !target.readonly) return false; // Lengths: `[рақам]` fits `[рақам, сатр?]`, `[рақам, ...сатр[]]` needs a rest element too const sourceMin = source.minLength ?? source.types.length; if (sourceMin < (target.minLength ?? target.types.length)) return false; const fits = source.restType ? target.restType !== undefined && this.isAssignable(source.restType, target.restType) : target.restType !== undefined || source.types.length <= target.types.length; if (!fits) return false; return source.types.every((sourceType, index) => { const targetType = this.tupleElementAt(target, index); const type = index >= sourceMin ? this.optionalType(sourceType) : sourceType; return targetType !== undefined && this.isAssignable(type, targetType); }); } /** `[1, 2] чун собит` or a `[рақам, сатр]` value where an array is expected. */ isTupleToArrayAssignable(source, target) { if (source.kind !== 'tuple' || target.kind !== 'array' || !source.types) return false; return source.types.every(t => this.isAssignable(t, target.elementType)); } isUnionAssignable(source, target) { if (source.kind === 'union' && source.types) { return source.types.every(t => this.isAssignable(t, target)); } if (target.kind === 'union' && target.types) { return target.types.some(t => this.isAssignable(source, t)); } return false; } isIntersectionAssignable(source, target) { if (target.kind === 'intersection' && target.types) { return target.types.every(t => this.isAssignable(source, t)); } if (source.kind === 'intersection' && source.types) { return source.types.some(t => this.isAssignable(t, target)); } return false; } isInterfaceAssignable(source, target) { if (target.kind !== 'interface' && target.kind !== 'object') { return false; } if (this.isSignatureAssignable(source, target)) return true; if (['interface', 'object', 'class'].includes(source.kind)) { // A type with call signatures needs a callable value if (target.callSignatures?.length && !source.callSignatures?.length) return false; return this.isStructurallyCompatible(source, target); } return false; } /** * A function is a value of a type with call signatures, and a class (or a * constructor) one of a type with construct signatures, when the type's * other members are optional; signatures are not compared, like functions. */ isSignatureAssignable(source, target) { const callable = source.kind === 'function' && Boolean(target.callSignatures?.length); const constructable = (source.kind === 'class' || source.kind === 'constructor') && Boolean(target.constructSignatures?.length); if (constructable) return true; if (!callable) return false; return [...this.getAllProperties(target).values()].every(property => property.optional); } /** * A class accepts its subclasses (base chain followed by name) and, like * TypeScript, any object whose members match its own. */ isClassAssignable(source, target) { if (target.kind !== 'class') return false; if (source.kind === 'class') { const visited = new Set(); for (let t = source; t && !visited.has(t.name); t = t.baseType) { if (t.name === target.name) return true; visited.add(t.name); } } if (['interface', 'object', 'class'].includes(source.kind)) { return this.isStructurallyCompatible(source, target); } return false; } /** `беназир рамз` is a `рамз`. */ isUniqueAssignable(source, target) { if (source.kind !== 'unique') return false; return this.isAssignable(source.baseType, target.kind === 'unique' ? target.baseType : target); } /** * All members of an object-like type; for classes this includes members * inherited along the base chain (own members override inherited ones). */ getAllProperties(type) { if (type.kind === 'intersection' && type.types) { const merged = new Map(); type.types.forEach(t => this.getAllProperties(t).forEach((p, k) => merged.set(k, p))); return merged; } if (!['interface', 'object', 'class'].includes(type.kind) || !type.properties) { return new Map(); } if (type.kind !== 'class' || !type.baseType) return type.properties; const chain = []; const visited = new Set(); for (let t = type; t && !visited.has(t.name); t = t.baseType) { chain.unshift(t); visited.add(t.name); } const merged = new Map(); chain.forEach(t => t.properties?.forEach((p, k) => merged.set(k, p))); return merged; } /** The type as SomonScript source writes it: `рақам[]`, `(х: сатр) => мантиқӣ`. */ typeToString(type) { const printer = this.typePrinters[type.kind]; // Interfaces and classes print by name return printer ? printer(type) : type.name; } /** `[рақам, сатр?, ...мантиқӣ[]]` */ tupleToString(type) { const types = type.types; const minLength = type.minLength ?? types.length; const parts = types.map((t, i) => `${this.typeToString(t)}${i >= minLength ? '?' : ''}`); if (type.restType) { parts.push(`...${this.typeToString({ kind: 'array', elementType: type.restType })}`); } return `${type.readonly ? 'танҳохонӣ ' : ''}[${parts.join(', ')}]`; } genericTypeToString(type) { const params = type.typeParameters ?? []; if (params.length === 0) return type.name; return `${type.name}<${this.typeListToString({ kind: 'list', types: params })}>`; } typeListToString(type) { const parts = type.types.map(t => this.typeToString(t)); switch (type.kind) { case 'union': return parts.join(' | '); case 'intersection': return parts.join(' & '); default: return parts.join(', '); } } objectTypeToString(type) { // The enum object itself, as TypeScript prints it (`typeof Ранг`) if (type.enumType) return `навъи ${type.name}`; const members = [...type.properties].map(([key, prop]) => `${key}${prop.optional ? '?' : ''}: ${this.typeToString(prop.type)}`); return members.length > 0 ? `{ ${members.join('; ')} }` : '{}'; } functionTypeToString(type) { const params = (type.paramTypes ?? []).map((p, i) => `${type.paramNames[i]}: ${this.typeToString(p)}`); return `(${params.join(', ')}) => ${this.typeToString(type.returnType)}`; } isStructurallyCompatible(source, target) { // Recursive types: assume compatibility for a pair already being compared if (this.assignabilityStack.some(([s, t]) => s === source && t === target)) { return true; } const sourceProperties = this.getAllProperties(source); const targetProperties = this.getAllProperties(target); this.assignabilityStack.push([source, target]); try { // Check if source has all required properties of target for (const [propName, targetProp] of targetProperties) { const sourceProp = sourceProperties.get(propName); // Required property missing if (!sourceProp && !targetProp.optional) { return false; } // Property exists, check type compatibility. Method signatures // (`ном(): сатр`) have function types; functions are compared // without their signatures. if (sourceProp && !this.isAssignable(sourceProp.type, targetProp.optional ? this.optionalType(targetProp.type) : targetProp.type)) { return false; } } return true; } finally { this.assignabilityStack.pop(); } } mapPrimitiveToTajik(primitiveType) { switch (primitiveType) { case 'string': return 'сатр'; case 'number': return 'рақам'; case 'boolean': return 'мантиқӣ'; case 'null': return 'холӣ'; case 'undefined': return 'беқимат'; case 'any': return 'ҳар'; case 'unknown': return 'ношинос'; case 'never': return 'абадан'; case 'void': return 'беджавоб'; case 'object': return 'объект'; case 'symbol': return 'рамз'; default: return primitiveType; } } addError(code, text, line, column) { if (this.silent > 0) return; this.errors.push(this.diagnostic(code, text, line, column, 'error')); } /** A diagnostic with its catalog message, whose id and values give its text in other languages. */ diagnostic(code, text, line, column, severity) { return { code, message: (0, catalog_1.renderMessage)(text, 'en'), line, column, snippet: this.getSnippet(line), severity, messageId: text.id, params: text.params, }; } addWarning(code, text, line, column) { if (this.silent > 0) return; this.warnings.push(this.diagnostic(code, text, line, column, 'warning')); } } exports.TypeChecker = TypeChecker; TypeChecker.BUILTIN_VALUE_NAMES = new Set([ // Tajik builtin globals (also present in codegen's builtinMappings) 'чоп', 'математика', 'Риёзӣ', 'объект', 'сатрМетодҳо', 'Хато', 'рӯйхат', 'сатр', 'ваъда', // Promise 'Ваъда', // Tajik literal keywords that surface as Identifier expressions 'беқимат', // undefined 'холӣ', // null (also a primitive type name) 'дуруст', // true 'нодуруст', // false 'ин', // this // Latin/JS builtins the generated code or examples reference by name 'console', 'Math', 'Object', 'Array', 'Date', 'JSON', 'Map', 'Set', 'Promise', 'Error', 'RegExp', 'Number', 'Boolean', 'String', 'Symbol', 'undefined', 'null', 'NaN', 'Infinity', 'parseInt', 'parseFloat', 'isNaN', 'isFinite', 'globalThis', 'this', 'arguments', // Host globals that may be absent from the checker's own globalThis 'require', 'module', 'exports', '__dirname', '__filename', 'process', 'Buffer', 'window', 'document', 'navigator', 'location', 'localStorage', 'sessionStorage', 'alert', 'fetch', ]); /** Declarations that only describe types: their names have no value to check. */ TypeChecker.TYPE_DECLARATIONS = new Set([ 'InterfaceDeclaration', 'TypeAlias', ]); /** Nodes whose code runs later than the expression containing them, with their own `ин`. */ TypeChecker.DEFERRED_NODES = new Set([ 'FunctionExpression', 'ArrowFunctionExpression', 'ClassExpression', ]); }, {"./builtin-globals":"builtin-globals.js","./builtin-names":"builtin-names.js","./diagnostics/catalog":"diagnostics/catalog.js","./diagnostics/suggest":"diagnostics/suggest.js","./syntactic-conditions":"syntactic-conditions.js","./type-names":"type-names.js"}, ], "type-names.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); exports.BUILTIN_TYPE_NAMES = exports.TYPE_NAMES = void 0; exports.declaredTypeNames = declaredTypeNames; exports.isUnknownTypeName = isUnknownTypeName; const builtin_names_1 = require("./builtin-names"); /** * TypeScript names of SomonScript's built-in type names: primitive types, * `Ваъда` and the utility types. */ exports.TYPE_NAMES = new Map([ ['рақам', 'number'], ['сатр', 'string'], ['мантиқӣ', 'boolean'], ['ҳар', 'any'], ['ношинос', 'unknown'], ['абадан', 'never'], ['беджавоб', 'void'], ['холӣ', 'null'], ['беқимат', 'undefined'], ['объект', 'object'], ['калонрақам', 'bigint'], ['рамз', 'symbol'], ['Ваъда', 'Promise'], ['ваъда', 'Promise'], ['рӯйхат', 'Array'], ['Хато', 'Error'], ['функсия', 'Function'], ['функция', 'Function'], ['қисмӣ', 'Partial'], ['ҳатмӣ', 'Required'], ['танҳохон', 'Readonly'], ['сабт_навъ', 'Record'], ['гирифтан_навъ', 'Pick'], ['ҳазф', 'Omit'], ['хориҷ', 'Exclude'], ['истихроҷ', 'Extract'], ['беналиӣ', 'NonNullable'], ['навъи_бозгашт', 'ReturnType'], ['параметрҳо', 'Parameters'], ['навъи_намуна', 'InstanceType'], ['параметрҳои_конструктор', 'ConstructorParameters'], ['навъи_параметри_ин', 'ThisParameterType'], ['интизоршуда', 'Awaited'], ]); /** Declarations whose `name` is a type, or may name one (`навъ`, `синф`, `<Т>`, …). */ const NAMED_DECLARATIONS = new Set([ 'InterfaceDeclaration', 'TypeAlias', 'ClassDeclaration', 'EnumDeclaration', 'NamespaceDeclaration', 'TypeParameter', 'FunctionDeclaration', ]); /** Imports: the name they bind (`ворид { К } аз …`, `ворид * чун Н аз …`, `ворид х = …`). */ const BINDING_FIELDS = { ImportSpecifier: 'local', ImportDefaultSpecifier: 'local', ImportNamespaceSpecifier: 'local', ImportEqualsDeclaration: 'id', }; /** * Every name a program declares that a type annotation may use, anywhere in * it: declarations are found wherever they are, so a type used before or * outside the block of its declaration is not mistaken for a missing one. */ function declaredTypeNames(program) { const names = new Set(); const visit = (node) => { const field = NAMED_DECLARATIONS.has(node.type) ? 'name' : BINDING_FIELDS[node.type]; const named = field && node[field]; if (named && typeof named.name === 'string') names.add(named.name); for (const value of Object.values(node)) { for (const child of Array.isArray(value) ? value : [value]) { if (child && typeof child === 'object' && typeof child.type === 'string') { visit(child); } } } }; visit(program); return names; } /** SomonScript's type names, and the Tajik names of built-in objects: `рақам`, `рӯйхат`, `Хато`, … */ exports.BUILTIN_TYPE_NAMES = new Set([ ...exports.TYPE_NAMES.keys(), ...builtin_names_1.BUILTIN_MAPPINGS.keys(), ]); /** * Whether the type checker should report a type name it cannot resolve. Only * names with Cyrillic letters are: names in Latin letters may be any type of * JavaScript's, TypeScript's or the browser's libraries, which the checker * does not list. */ function isUnknownTypeName(name, declared) { return (/[\u0400-\u04FF]/.test(name) && !name.includes('.') && !exports.BUILTIN_TYPE_NAMES.has(name) && !declared.has(name)); } }, {"./builtin-names":"builtin-names.js"}, ], "type-system.js": [ function (module, exports, require) { "use strict"; Object.defineProperty(exports, "__esModule", { value: true }); }, {}, ], "types.js": [ function (module, exports, require) { "use strict"; var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { if (k2 === undefined) k2 = k; var desc = Object.getOwnPropertyDescriptor(m, k); if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { desc = { enumerable: true, get: function() { return m[k]; } }; } Object.defineProperty(o, k2, desc); }) : (function(o, m, k, k2) { if (k2 === undefined) k2 = k; o[k2] = m[k]; })); var __exportStar = (this && this.__exportStar) || function(m, exports) { for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); }; Object.defineProperty(exports, "__esModule", { value: true }); // Re-export all types from modular files for backward compatibility __exportStar(require("./tokens"), exports); __exportStar(require("./ast"), exports); __exportStar(require("./type-system"), exports); }, {"./tokens":"tokens.js","./ast":"ast.js","./type-system":"type-system.js"}, ], }; var cache = {}; function load(id) { if (cache[id]) return cache[id].exports; var definition = modules[id]; var module = (cache[id] = { exports: {} }); definition[0].call(module.exports, module, module.exports, function (specifier) { return load(definition[1][specifier]); }); return module.exports; } return load("playground/worker.js"); });

Барнома

Масъала

Вуруд

Натиҷа

JavaScript