ArkScript-lang/Ark | Build 22281229261 | src/arkreactor/Compiler/AST/Parser.cpp | Coveralls

7

    Parser::Parser(const unsigned debug, const ParserMode mode) :

1,386✔

8

        BaseParser(), m_mode(mode), m_logger("Parser", debug),

693✔

9

        m_ast(NodeType::List), m_imports({}), m_allow_macro_behavior(0),

693✔

10

        m_nested_nodes(0)

693✔

11

693✔

12

        m_ast.push_back(Node(Keyword::Begin));

693✔

14

        m_parsers = {

1,386✔

15

            [this](FilePosition) {

73,827✔

16

                return wrapped(&Parser::letMutSet, "variable assignment or declaration");

73,134✔

17

},

9✔

18

            [this](FilePosition) {

63,423✔

19

                return wrapped(&Parser::function, "function");

62,730✔

20

},

8✔

21

            [this](FilePosition) {

59,532✔

22

                return wrapped(&Parser::condition, "condition");

58,839✔

23

},

3✔

24

            [this](FilePosition) {

57,650✔

25

                return wrapped(&Parser::loop, "loop");

56,957✔

26

},

2✔

27

            [this](const FilePosition filepos) {

56,390✔

28

                return import_(filepos);

55,697✔

30

            [this](const FilePosition filepos) {

56,157✔

31

                return block(filepos);

55,464✔

33

            [this](FilePosition) {

52,732✔

34

                return wrapped(&Parser::macroCondition, "$if");

52,039✔

35

},

2✔

36

            [this](const FilePosition filepos) {

52,677✔

37

                return macro(filepos);

51,984✔

39

            [this](FilePosition) {

52,508✔

40

                return wrapped(&Parser::del, "del");

51,815✔

41

},

1✔

42

            [this](const FilePosition filepos) {

52,496✔

43

                return functionCall(filepos);

51,803✔

45

            [this](const FilePosition filepos) {

29,858✔

46

                return list(filepos);

29,165✔

49

693✔

51

    void Parser::process(const std::string& filename, const std::string& code)

693✔

52

693✔

53

        m_logger.traceStart("process");

749✔

54

        initParser(filename, code);

693✔

56

        while (!isEOF())

5,707✔

58

            std::string comment = newlineOrComment();

5,650✔

59

            if (isEOF())

5,650✔

61

                if (!comment.empty())

580✔

62

                    m_ast.list().back().attachCommentAfter(comment);

2✔

63

                break;

580✔

66

            const auto pos = getCount();

5,070✔

67

            if (auto n = node())

10,140✔

69

                m_ast.push_back(n->attachNearestCommentBefore(n->comment() + comment));

5,014✔

70

                m_ast.list().back().attachCommentAfter(spaceComment());

5,014✔

71

5,014✔

74

                backtrack(pos);

6✔

75

                std::string out = peek();

6✔

76

                std::string message;

6✔

77

                if (out == ")")

6✔

78

                    message = "Unexpected closing paren";

1✔

79

                else if (out == "}")

5✔

80

                    message = "Unexpected closing bracket";

1✔

81

                else if (out == "]")

4✔

82

                    message = "Unexpected closing square bracket";

1✔

84

                    errorWithNextToken("invalid syntax, expected node");

3✔

85

                errorWithNextToken(message);

3✔

86

6✔

87

5,650✔

89

        m_logger.traceEnd();

637✔

90

693✔

92

    const Node& Parser::ast() const noexcept

652✔

93

652✔

94

        return m_ast;

652✔

97

    const std::vector<Import>& Parser::imports() const

563✔

98

563✔

99

        return m_imports;

563✔

102

    Node Parser::positioned(Node node, const FilePosition cursor) const

165,313✔

103

165,313✔

104

        const auto [row, col] = cursor;

495,939✔

105

        const auto [end_row, end_col] = getCursor();

495,939✔

107

        node.m_filename = m_filename;

165,313✔

108

        node.m_pos = FileSpan {

330,626✔

109

            .start = FilePos { .line = row, .column = col },

495,939✔

110

            .end = FilePos { .line = end_row, .column = end_col }

495,939✔

112

        return node;

165,313✔

113

165,313✔

115

    std::optional<Node>& Parser::positioned(std::optional<Node>& node, const FilePosition cursor) const

49,507✔

116

49,507✔

117

        if (!node)

49,507✔

120

        const auto [row, col] = cursor;

148,521✔

121

        const auto [end_row, end_col] = getCursor();

148,521✔

123

        node->m_filename = m_filename;

49,507✔

124

        node->m_pos = FileSpan {

99,014✔

125

            .start = FilePos { .line = row, .column = col },

148,521✔

126

            .end = FilePos { .line = end_row, .column = end_col }

148,521✔

128

        return node;

49,507✔

129

49,507✔

131

    std::optional<Node> Parser::node()

73,135✔

132

73,135✔

133

        ++m_nested_nodes;

73,135✔

135

        if (m_nested_nodes > MaxNestedNodes)

73,135✔

136

            errorWithNextToken(fmt::format("Too many nested node while parsing, exceeds limit of {}. Consider rewriting your code by breaking it in functions and macros.", MaxNestedNodes));

1,084✔

139

        const auto position = getCount();

73,134✔

140

        const auto filepos = getCursor();

73,134✔

141

        std::optional<Node> result = std::nullopt;

73,134✔

143

        for (auto&& parser : m_parsers)

672,761✔

145

            result = parser(filepos);

599,627✔

147

            if (result)

598,544✔

148

                break;

44,568✔

149

            backtrack(position);

553,976✔

150

599,627✔

153

        --m_nested_nodes;

72,051✔

154

        return result;

72,051✔

155

73,135✔

157

    std::optional<Node> Parser::letMutSet(const FilePosition filepos)

40,554✔

158

40,554✔

159

        std::optional<Node> leaf { NodeType::List };

40,554✔

161

        std::string token;

40,554✔

162

        if (!oneOf({ "let", "mut", "set" }, &token))

40,554✔

163

            return std::nullopt;

30,150✔

165

        std::string comment = newlineOrComment();

10,404✔

166

        leaf->attachNearestCommentBefore(comment);

10,404✔

168

        if (token == "let")

10,404✔

169

            leaf->push_back(Node(Keyword::Let));

5,194✔

170

        else if (token == "mut")

5,210✔

171

            leaf->push_back(Node(Keyword::Mut));

2,823✔

173

            leaf->push_back(Node(Keyword::Set));

2,387✔

175

        if (m_allow_macro_behavior > 0)

10,404✔

177

            const auto position = getCount();

55✔

178

            const auto value_pos = getCursor();

55✔

179

            if (const auto value = nodeOrValue(); value.has_value())

110✔

181

                const Node& sym = value.value();

55✔

182

                if (sym.nodeType() == NodeType::List || sym.nodeType() == NodeType::Symbol || sym.nodeType() == NodeType::Macro || sym.nodeType() == NodeType::Spread)

55✔

183

                    leaf->push_back(sym);

54✔

185

                    error(fmt::format("Can not use a {} as a symbol name, even in a macro", nodeTypes[static_cast<std::size_t>(sym.nodeType())]), value_pos);

1✔

186

55✔

189

55✔

191

        if (leaf->constList().size() == 1)

10,403✔

194

            std::string symbol_name;

10,349✔

195

            const auto value_pos = getCursor();

10,349✔

196

            if (!name(&symbol_name))

10,349✔

197

                errorWithNextToken(token + " needs a symbol");

2✔

199

            leaf->push_back(positioned(Node(NodeType::Symbol, symbol_name), value_pos));

10,347✔

200

10,349✔

202

        comment = newlineOrComment();

10,401✔

203

        if (auto value = nodeOrValue(); value.has_value())

20,802✔

204

            leaf->push_back(value.value().attachNearestCommentBefore(comment));

10,395✔

208

        return positioned(leaf, filepos);

10,395✔

209

40,563✔

211

    std::optional<Node> Parser::del(const FilePosition filepos)

22,651✔

212

22,651✔

213

        std::optional<Node> leaf { NodeType::List };

22,651✔

215

        if (!oneOf({ "del" }))

22,651✔

216

            return std::nullopt;

22,639✔

217

        leaf->push_back(Node(Keyword::Del));

12✔

219

        const std::string comment = newlineOrComment();

12✔

221

        std::string symbol_name;

12✔

222

        if (!name(&symbol_name))

12✔

223

            errorWithNextToken("del needs a symbol");

1✔

225

        leaf->push_back(Node(NodeType::Symbol, symbol_name));

11✔

226

        leaf->list().back().attachNearestCommentBefore(comment);

11✔

228

        return positioned(leaf, filepos);

11✔

229

22,652✔

231

    std::optional<Node> Parser::condition(const FilePosition filepos)

26,259✔

232

26,259✔

233

        std::optional<Node> leaf { NodeType::List };

26,259✔

235

        if (!oneOf({ "if" }))

26,259✔

236

            return std::nullopt;

24,377✔

238

        std::string comment = newlineOrComment();

1,882✔

240

        leaf->push_back(Node(Keyword::If));

1,882✔

242

        if (auto cond_expr = nodeOrValue(); cond_expr.has_value())

3,764✔

243

            leaf->push_back(cond_expr.value().attachNearestCommentBefore(comment));

1,881✔

245

            errorWithNextToken("`if' needs a valid condition");

1✔

247

        comment = newlineOrComment();

1,881✔

248

        if (auto value_if_true = nodeOrValue(); value_if_true.has_value())

3,762✔

249

            leaf->push_back(value_if_true.value().attachNearestCommentBefore(comment));

1,880✔

251

            errorWithNextToken("Expected a node or value after condition");

1✔

253

        comment = newlineOrComment();

1,880✔

254

        if (auto value_if_false = nodeOrValue(); value_if_false.has_value())

3,760✔

256

            leaf->push_back(value_if_false.value().attachNearestCommentBefore(comment));

1,138✔

257

            leaf->list().back().attachCommentAfter(newlineOrComment());

1,138✔

258

1,138✔

259

        else if (!comment.empty())

742✔

260

            leaf->attachCommentAfter(comment);

2✔

262

        return positioned(leaf, filepos);

1,880✔

263

26,261✔

265

    std::optional<Node> Parser::loop(const FilePosition filepos)

24,377✔

266

24,377✔

267

        std::optional<Node> leaf { NodeType::List };

24,377✔

269

        if (!oneOf({ "while" }))

24,377✔

270

            return std::nullopt;

23,117✔

272

        std::string comment = newlineOrComment();

1,260✔

273

        leaf->push_back(Node(Keyword::While));

1,260✔

275

        if (auto cond_expr = nodeOrValue(); cond_expr.has_value())

2,520✔

276

            leaf->push_back(cond_expr.value().attachNearestCommentBefore(comment));

1,259✔

278

            errorWithNextToken("`while' needs a valid condition");

1✔

280

        comment = newlineOrComment();

1,259✔

281

        if (auto body = nodeOrValue(); body.has_value())

2,518✔

282

            leaf->push_back(body.value().attachNearestCommentBefore(comment));

1,258✔

284

            errorWithNextToken("Expected a node or value after loop condition");

1✔

286

        return positioned(leaf, filepos);

1,258✔

287

24,379✔

289

    std::optional<Node> Parser::import_(const FilePosition filepos)

55,697✔

290

55,697✔

291

        std::optional<Node> leaf { NodeType::List };

55,697✔

293

        auto context = generateErrorContextAtCurrentPosition();

55,697✔

294

        if (!accept(IsChar('(')))

55,697✔

295

            return std::nullopt;

32,580✔

297

        std::string comment = newlineOrComment();

23,117✔

298

        leaf->attachNearestCommentBefore(comment);

23,117✔

300

        if (!oneOf({ "import" }))

23,117✔

301

            return std::nullopt;

22,884✔

303

        comment = newlineOrComment();

233✔

304

        leaf->push_back(Node(Keyword::Import));

233✔

306

        Import import_data;

233✔

307

        import_data.col = filepos.col;

233✔

308

        import_data.line = filepos.row;

233✔

310

        const auto pos = getCount();

233✔

311

        if (!packageName(&import_data.prefix))

233✔

312

            errorWithNextToken("Import expected a package name");

1✔

314

        if (import_data.prefix.size() > 255)

232✔

316

            backtrack(pos);

1✔

317

            errorWithNextToken(fmt::format("Import name too long, expected at most 255 characters, got {}", import_data.prefix.size()));

1✔

319

        import_data.package.push_back(import_data.prefix);

231✔

321

        Node packageNode = positioned(Node(NodeType::List), getCursor()).attachNearestCommentBefore(comment);

231✔

322

        packageNode.push_back(Node(NodeType::Symbol, import_data.prefix));

231✔

325

        while (!isEOF())

405✔

327

            const auto item_pos = getCursor();

405✔

330

            if (accept(IsChar('.')))

405✔

332

                const auto package_pos = getCursor();

177✔

333

                std::string path;

177✔

334

                if (!packageName(&path))

177✔

335

                    errorWithNextToken("Package name expected after '.'");

2✔

338

                    packageNode.push_back(positioned(Node(NodeType::Symbol, path), package_pos));

175✔

340

                    import_data.package.push_back(path);

175✔

341

                    import_data.prefix = path;  // in the end we will store the last element of the package, which is what we want

175✔

343

                    if (path.size() > 255)

175✔

345

                        backtrack(pos);

1✔

346

                        errorWithNextToken(fmt::format("Import name too long, expected at most 255 characters, got {}", path.size()));

1✔

349

177✔

350

            else if (accept(IsChar(':')) && accept(IsChar('*')))  // parsing :*, terminal in imports

228✔

352

                leaf->push_back(packageNode);

11✔

353

                leaf->push_back(positioned(Node(NodeType::Symbol, "*"), item_pos));

11✔

355

                space();

11✔

356

                expectSuffixOrError(')', fmt::format("in import `{}'", import_data.toPackageString()), context);

11✔

359

                import_data.with_prefix = false;

11✔

360

                import_data.is_glob = true;

11✔

361

                m_imports.push_back(import_data);

11✔

363

                return positioned(leaf, filepos);

11✔

366

                break;

217✔

367

405✔

369

        Node symbols = positioned(Node(NodeType::List), getCursor());

217✔

371

        if (space())

217✔

373

            comment = newlineOrComment();

83✔

375

            while (!isEOF())

151✔

377

                if (accept(IsChar(':')))  // parsing potential :a :b :c

151✔

379

                    const auto symbol_pos = getCursor();

148✔

380

                    std::string symbol_name;

148✔

381

                    if (!name(&symbol_name))

148✔

382

                        errorWithNextToken("Expected a valid symbol to import");

1✔

383

                    if (symbol_name == "*")

147✔

384

                        error(fmt::format("Glob patterns can not be separated from the package, use (import {}:*) instead", import_data.toPackageString()), symbol_pos);

1✔

386

                    if (symbol_name.size() >= 2 && symbol_name[symbol_name.size() - 2] == ':' && symbol_name.back() == '*')

146✔

387

                        error("Glob pattern can not follow a symbol to import", FilePosition { .row = symbol_pos.row, .col = symbol_pos.col + symbol_name.size() - 2 });

1✔

389

                    symbols.push_back(positioned(Node(NodeType::Symbol, symbol_name).attachNearestCommentBefore(comment), symbol_pos));

145✔

390

                    comment.clear();

145✔

392

                    import_data.symbols.push_back(symbol_name);

145✔

394

                    import_data.with_prefix = false;

145✔

395

148✔

397

                if (!space())

148✔

398

                    break;

80✔

399

                comment = newlineOrComment();

68✔

402

            if (!comment.empty() && !symbols.list().empty())

80✔

403

                symbols.list().back().attachCommentAfter(comment);

2✔

404

80✔

406

        leaf->push_back(packageNode);

214✔

407

        leaf->push_back(symbols);

214✔

409

        m_imports.push_back(import_data);

214✔

411

        comment = newlineOrComment();

214✔

412

        if (!comment.empty())

214✔

413

            leaf->list().back().attachCommentAfter(comment);

1✔

415

        expectSuffixOrError(')', fmt::format("in import `{}'", import_data.toPackageString()), context);

214✔

416

        return positioned(leaf, filepos);

214✔

417

55,705✔

419

    std::optional<Node> Parser::block(const FilePosition filepos)

55,464✔

420

55,464✔

421

        std::optional<Node> leaf { NodeType::List };

55,464✔

423

        auto context = generateErrorContextAtCurrentPosition();

55,464✔

424

        bool alt_syntax = false;

55,464✔

425

        std::string comment;

55,464✔

426

        if (accept(IsChar('(')))

55,464✔

428

            comment = newlineOrComment();

22,884✔

429

            if (!oneOf({ "begin" }))

22,884✔

430

                return std::nullopt;

22,875✔

431

9✔

432

        else if (accept(IsChar('{')))

32,580✔

433

            alt_syntax = true;

3,416✔

435

            return std::nullopt;

29,164✔

437

        leaf->setAltSyntax(alt_syntax);

3,425✔

438

        leaf->push_back(Node(Keyword::Begin).attachNearestCommentBefore(comment));

3,425✔

440

        comment = newlineOrComment();

3,425✔

442

        while (!isEOF())

15,305✔

444

            if (auto value = nodeOrValue(); value.has_value())

30,608✔

446

                leaf->push_back(value.value().attachNearestCommentBefore(comment));

11,880✔

447

                comment = newlineOrComment();

11,880✔

448

11,880✔

450

                break;

3,423✔

453

        comment += newlineOrComment();

3,424✔

454

        expectSuffixOrError(alt_syntax ? '}' : ')', "to close block", context);

3,424✔

455

        leaf->list().back().attachCommentAfter(comment);

3,423✔

456

        return positioned(leaf, filepos);

3,423✔

457

55,466✔

459

    std::optional<Node> Parser::functionArgs(const FilePosition filepos)

3,867✔

460

3,867✔

461

        expect(IsChar('('));

3,870✔

462

        std::optional<Node> args { NodeType::List };

3,867✔

464

        std::string comment = newlineOrComment();

3,867✔

465

        args->attachNearestCommentBefore(comment);

3,867✔

467

        bool has_captures = false;

3,867✔

469

        while (!isEOF())

10,109✔

471

            const auto pos = getCursor();

10,108✔

472

            if (accept(IsChar('&')))  // captures

10,108✔

474

                has_captures = true;

293✔

475

                std::string capture;

293✔

476

                if (!name(&capture))

293✔

477

                    error("No symbol provided to capture", pos);

1✔

479

                args->push_back(positioned(Node(NodeType::Capture, capture), pos));

292✔

480

293✔

481

            else if (accept(IsChar('(')))

9,815✔

484

                std::string modifier;

975✔

485

                std::ignore = newlineOrComment();

975✔

486

                if (!oneOf({ "mut", "ref" }, &modifier))

975✔

490

                    return std::nullopt;

1✔

492

                NodeType type = NodeType::Unused;

974✔

493

                if (modifier == "mut")

974✔

494

                    type = NodeType::MutArg;

104✔

495

                else if (modifier == "ref")

870✔

496

                    type = NodeType::RefArg;

870✔

498

                Node arg_with_attr = Node(type);

974✔

499

                std::string comment2 = newlineOrComment();

974✔

500

                arg_with_attr.attachCommentAfter(comment2);

974✔

502

                std::string symbol_name;

974✔

503

                if (!name(&symbol_name))

974✔

504

                    error(fmt::format("Expected a symbol name for the attribute with modifier `{}'", modifier), pos);

1✔

505

                arg_with_attr.setString(symbol_name);

973✔

507

                args->push_back(positioned(arg_with_attr, pos));

973✔

508

                std::ignore = newlineOrComment();

973✔

509

                expect(IsChar(')'));

973✔

510

975✔

513

                std::string symbol_name;

8,840✔

514

                if (!name(&symbol_name))

8,840✔

515

                    break;

3,862✔

516

                if (has_captures)

4,978✔

517

                    error("Captured variables should be at the end of the argument list", pos);

1✔

519

                args->push_back(positioned(Node(NodeType::Symbol, symbol_name), pos));

4,977✔

520

8,840✔

522

            if (!comment.empty())

6,242✔

523

                args->list().back().attachNearestCommentBefore(comment);

12✔

524

            comment = newlineOrComment();

6,242✔

525

10,108✔

527

        if (accept(IsChar(')')))

3,863✔

528

            return positioned(args, filepos);

3,862✔

529

        return std::nullopt;

1✔

530

3,870✔

532

    std::optional<Node> Parser::function(const FilePosition filepos)

30,150✔

533

30,150✔

534

        std::optional<Node> leaf { NodeType::List };

30,150✔

536

        if (!oneOf({ "fun" }))

30,150✔

537

            return std::nullopt;

26,259✔

538

        leaf->push_back(Node(Keyword::Fun));

3,891✔

540

        const std::string comment_before_args = newlineOrComment();

3,891✔

542

        while (m_allow_macro_behavior > 0)

3,891✔

544

            const auto position = getCount();

24✔

547

            if (const auto value = nodeOrValue(); value.has_value())

48✔

551

                const Node& args = value.value();

24✔

552

                if (args.nodeType() == NodeType::Symbol && args.string() == "nil")

24✔

553

                    leaf->push_back(Node(NodeType::List));

6✔

555

                    leaf->push_back(args);

18✔

556

24✔

563

            const std::string comment = newlineOrComment();

24✔

565

            if (auto value = nodeOrValue(); value.has_value())

48✔

566

                leaf->push_back(value.value().attachNearestCommentBefore(comment));

23✔

568

                errorWithNextToken("Expected a body for the function");

1✔

569

            return positioned(leaf, filepos);

23✔

570

24✔

572

        const auto position = getCount();

3,867✔

573

        const auto args_file_pos = getCursor();

3,867✔

574

        if (auto args = functionArgs(args_file_pos); args.has_value())

7,734✔

575

            leaf->push_back(args.value().attachNearestCommentBefore(comment_before_args));

3,862✔

578

            backtrack(position);

2✔

580

            if (auto value = nodeOrValue(); value.has_value())

4✔

581

                leaf->push_back(value.value().attachNearestCommentBefore(comment_before_args));

1✔

586

        const std::string comment = newlineOrComment();

3,863✔

588

        if (auto value = nodeOrValue(); value.has_value())

7,726✔

589

            leaf->push_back(value.value().attachNearestCommentBefore(comment));

3,861✔

591

            errorWithNextToken("Expected a body for the function");

2✔

593

        return positioned(leaf, filepos);

3,861✔

594

30,157✔

596

    std::optional<Node> Parser::macroCondition(const FilePosition filepos)

22,875✔

597

22,875✔

598

        std::optional<Node> leaf { NodeType::Macro };

22,875✔

600

        if (!oneOf({ "$if" }))

22,875✔

601

            return std::nullopt;

22,820✔

602

        leaf->push_back(Node(Keyword::If));

55✔

604

        std::string comment = newlineOrComment();

55✔

605

        leaf->attachNearestCommentBefore(comment);

55✔

607

        if (const auto cond_expr = nodeOrValue(); cond_expr.has_value())

110✔

608

            leaf->push_back(cond_expr.value());

54✔

610

            errorWithNextToken("$if need a valid condition");

1✔

612

        comment = newlineOrComment();

54✔

613

        if (auto value_if_true = nodeOrValue(); value_if_true.has_value())

108✔

614

            leaf->push_back(value_if_true.value().attachNearestCommentBefore(comment));

53✔

616

            errorWithNextToken("Expected a node or value after condition");

1✔

618

        comment = newlineOrComment();

53✔

619

        if (auto value_if_false = nodeOrValue(); value_if_false.has_value())

92✔

621

            leaf->push_back(value_if_false.value().attachNearestCommentBefore(comment));

39✔

622

            comment = newlineOrComment();

39✔

623

            leaf->list().back().attachCommentAfter(comment);

39✔

624

39✔

626

        return positioned(leaf, filepos);

53✔

627

22,877✔

629

    std::optional<Node> Parser::macroArgs(const FilePosition filepos)

168✔

630

168✔

631

        if (!accept(IsChar('(')))

172✔

632

            return std::nullopt;

25✔

634

        std::optional<Node> args { NodeType::List };

143✔

636

        std::string comment = newlineOrComment();

143✔

637

        args->attachNearestCommentBefore(comment);

143✔

639

        std::vector<std::string> names;

143✔

640

        while (!isEOF())

343✔

642

            const auto pos = getCount();

342✔

644

            std::string arg_name;

342✔

645

            if (!name(&arg_name))

342✔

646

                break;

141✔

648

            comment = newlineOrComment();

201✔

649

            args->push_back(Node(NodeType::Symbol, arg_name).attachNearestCommentBefore(comment));

201✔

651

            if (std::ranges::find(names, arg_name) != names.end())

201✔

653

                backtrack(pos);

1✔

654

                errorWithNextToken(fmt::format("Argument names must be unique, can not reuse `{}'", arg_name));

1✔

656

            names.push_back(arg_name);

200✔

657

342✔

659

        const auto pos = getCount();

142✔

660

        if (sequence("..."))

142✔

662

            std::string spread_name;

48✔

663

            if (!name(&spread_name))

48✔

664

                errorWithNextToken("Expected a name for the variadic arguments list");

2✔

666

            args->push_back(Node(NodeType::Spread, spread_name));

46✔

667

            args->list().back().attachCommentAfter(newlineOrComment());

46✔

669

            if (std::ranges::find(names, spread_name) != names.end())

46✔

671

                backtrack(pos);

1✔

672

                errorWithNextToken(fmt::format("Argument names must be unique, can not reuse `{}'", spread_name));

1✔

674

48✔

676

        if (!accept(IsChar(')')))

139✔

677

            return std::nullopt;

34✔

679

        comment = newlineOrComment();

105✔

680

        if (!comment.empty())

105✔

681

            args->attachCommentAfter(comment);

4✔

683

        return positioned(args, filepos);

105✔

684

172✔

686

    std::optional<Node> Parser::macro(const FilePosition filepos)

51,984✔

687

51,984✔

688

        std::optional<Node> leaf { NodeType::Macro };

51,984✔

690

        auto context = generateErrorContextAtCurrentPosition();

51,984✔

691

        if (!accept(IsChar('(')))

51,984✔

692

            return std::nullopt;

29,164✔

694

        if (!oneOf({ "macro" }))

22,820✔

695

            return std::nullopt;

22,651✔

696

        std::string comment = newlineOrComment();

169✔

697

        leaf->attachNearestCommentBefore(comment);

169✔

699

        std::string symbol_name;

169✔

700

        if (!name(&symbol_name))

169✔

701

            errorWithNextToken("Expected a symbol to declare a macro");

1✔

703

        comment = newlineOrComment();

168✔

704

        leaf->push_back(Node(NodeType::Symbol, symbol_name).attachNearestCommentBefore(comment));

168✔

706

        const auto position = getCount();

168✔

707

        const auto args_file_pos = getCursor();

168✔

708

        if (const auto args = macroArgs(args_file_pos); args.has_value())

336✔

709

            leaf->push_back(args.value());

105✔

713

            backtrack(position);

59✔

715

            ++m_allow_macro_behavior;

59✔

716

            const auto value = nodeOrValue();

59✔

717

            --m_allow_macro_behavior;

57✔

719

            if (value.has_value())

57✔

720

                leaf->push_back(value.value());

56✔

722

                errorWithNextToken(fmt::format("Expected an argument list, atom or node while defining macro `{}'", symbol_name));

1✔

724

            leaf->list().back().attachCommentAfter(newlineOrComment());

56✔

725

            expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);

56✔

726

            return positioned(leaf, filepos);

55✔

727

59✔

729

        ++m_allow_macro_behavior;

105✔

730

        const auto value = nodeOrValue();

105✔

731

        --m_allow_macro_behavior;

103✔

733

        if (value.has_value())

103✔

734

            leaf->push_back(value.value());

99✔

735

        else if (leaf->list().size() == 2)  // the argument list is actually a function call and it's okay

4✔

737

            leaf->list().back().attachCommentAfter(newlineOrComment());

4✔

739

            expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);

4✔

740

            return positioned(leaf, filepos);

4✔

748

        leaf->list().back().attachCommentAfter(newlineOrComment());

99✔

750

        expectSuffixOrError(')', fmt::format("to close macro `{}'", symbol_name), context);

99✔

751

        return positioned(leaf, filepos);

99✔

752

51,993✔

754

    std::optional<Node> Parser::functionCall(const FilePosition filepos)

51,803✔

755

51,803✔

756

        auto context = generateErrorContextAtCurrentPosition();

51,803✔

757

        if (!accept(IsChar('(')))

51,803✔

758

            return std::nullopt;

29,164✔

759

        std::string comment = newlineOrComment();

22,639✔

761

        const auto func_name_pos = getCursor();

22,639✔

762

        std::optional<Node> func;

22,639✔

763

        if (auto sym_or_field = anyAtomOf({ NodeType::Symbol, NodeType::Field }); sym_or_field.has_value())

45,278✔

764

            func = sym_or_field->attachNearestCommentBefore(comment);

21,571✔

765

        else if (auto nested = node(); nested.has_value())

2,136✔

766

            func = nested->attachNearestCommentBefore(comment);

43✔

768

            return std::nullopt;

1✔

770

        if (func.value().nodeType() == NodeType::Symbol && func.value().string() == "ref")

21,614✔

771

            error("`ref' can not be used outside a function's arguments list.", func_name_pos);

1✔

773

        std::optional<Node> leaf { NodeType::List };

21,613✔

774

        leaf->push_back(positioned(func.value(), func_name_pos));

21,613✔

776

        comment = newlineOrComment();

21,613✔

778

        while (!isEOF())

129,526✔

780

            if (auto arg = nodeOrValue(); arg.has_value())

259,044✔

782

                leaf->push_back(arg.value().attachNearestCommentBefore(comment));

107,913✔

783

                comment = newlineOrComment();

107,913✔

784

107,913✔

786

                break;

21,602✔

789

        leaf->list().back().attachCommentAfter(comment);

21,606✔

790

        comment = newlineOrComment();

21,606✔

791

        if (!comment.empty())

21,606✔

794

        expectSuffixOrError(')', fmt::format("in function call to `{}'", func.value().repr()), context);

21,606✔

795

        return positioned(leaf, filepos);

21,602✔

796

52,839✔

798

    std::optional<Node> Parser::list(const FilePosition filepos)

29,165✔

799

29,165✔

800

        std::optional<Node> leaf { NodeType::List };

29,165✔

802

        auto context = generateErrorContextAtCurrentPosition();

29,165✔

803

        if (!accept(IsChar('[')))

29,165✔

804

            return std::nullopt;

27,483✔

805

        leaf->setAltSyntax(true);

1,682✔

806

        leaf->push_back(Node(NodeType::Symbol, "list"));

1,682✔

808

        std::string comment = newlineOrComment();

1,682✔

809

        leaf->attachNearestCommentBefore(comment);

1,682✔

811

        while (!isEOF())

4,055✔

813

            if (auto value = nodeOrValue(); value.has_value())

8,108✔

815

                leaf->push_back(value.value().attachNearestCommentBefore(comment));

2,373✔

816

                comment = newlineOrComment();

2,373✔

817

2,373✔

819

                break;

1,681✔

821

        leaf->list().back().attachCommentAfter(comment);

1,682✔

823

        expectSuffixOrError(']', "to end list definition", context);

1,682✔

824

        return positioned(leaf, filepos);

1,681✔

825

29,166✔

827

    std::optional<Node> Parser::number(const FilePosition filepos)

194,376✔

828

194,376✔

829

        std::string res;

194,376✔

830

        if (signedNumber(&res))

194,376✔

832

            double output;

78,317✔

833

            if (Utils::isDouble(res, &output))

78,317✔

834

                return positioned(Node(output), filepos);

78,316✔

836

            error("Is not a valid number", filepos);

1✔

837

78,317✔

838

        return std::nullopt;

116,059✔

839

194,377✔

841

    std::optional<Node> Parser::string(const FilePosition filepos)

116,059✔

842

116,059✔

843

        std::string res;

116,059✔

844

        if (accept(IsChar('"')))

116,059✔

846

            while (true)

30,381✔

848

                const auto pos = getCursor();

30,381✔

850

                if (accept(IsChar('\\')))

30,381✔

852

                    if (m_mode != ParserMode::Interpret)

438✔

853

                        res += '\\';

28✔

855

                    if (accept(IsChar('"')))

438✔

856

                        res += '"';

61✔

857

                    else if (accept(IsChar('\\')))

377✔

858

                        res += '\\';

35✔

859

                    else if (accept(IsChar('n')))

342✔

860

                        res += m_mode == ParserMode::Interpret ? '\n' : 'n';

145✔

861

                    else if (accept(IsChar('t')))

197✔

862

                        res += m_mode == ParserMode::Interpret ? '\t' : 't';

94✔

863

                    else if (accept(IsChar('v')))

103✔

864

                        res += m_mode == ParserMode::Interpret ? '\v' : 'v';

2✔

865

                    else if (accept(IsChar('r')))

101✔

866

                        res += m_mode == ParserMode::Interpret ? '\r' : 'r';

82✔

867

                    else if (accept(IsChar('a')))

19✔

868

                        res += m_mode == ParserMode::Interpret ? '\a' : 'a';

2✔

869

                    else if (accept(IsChar('b')))

17✔

870

                        res += m_mode == ParserMode::Interpret ? '\b' : 'b';

2✔

871

                    else if (accept(IsChar('f')))

15✔

872

                        res += m_mode == ParserMode::Interpret ? '\f' : 'f';

2✔

873

                    else if (accept(IsChar('u')))

13✔

875

                        std::string seq;

5✔

876

                        if (hexNumber(4, &seq))

5✔

878

                            if (m_mode == ParserMode::Interpret)

4✔

880

                                char utf8_str[5];

2✔

881

                                utf8::decode(seq.c_str(), utf8_str);

2✔

882

                                if (*utf8_str == '\0')

2✔

884

                                res += utf8_str;

2✔

885

2✔

887

                                res += "u" + seq;

2✔

888

4✔

890

                            error("Invalid escape sequence, expected 4 hex digits: \\uabcd", pos);

1✔

891

5✔

892

                    else if (accept(IsChar('U')))

8✔

894

                        std::string seq;

6✔

895

                        if (hexNumber(8, &seq))

6✔

897

                            if (m_mode == ParserMode::Interpret)

5✔

899

                                std::size_t begin = 0;

3✔

900

                                for (; seq[begin] == '0'; ++begin)

9✔

902

                                char utf8_str[5];

3✔

903

                                utf8::decode(seq.c_str() + begin, utf8_str);

3✔

904

                                if (*utf8_str == '\0')

3✔

905

                                    error("Invalid escape sequence", pos);

1✔

906

                                res += utf8_str;

2✔

907

3✔

909

                                res += "U" + seq;

2✔

910

4✔

912

                            error("Invalid escape sequence, expected 8 hex digits: \\UABCDEF78", pos);

1✔

913

6✔

916

                        backtrack(getCount() - 1);

2✔

917

                        error("Unknown escape sequence", pos);

2✔

919

433✔

921

                    accept(IsNot(IsEither(IsChar('\\'), IsChar('"'))), &res);

29,943✔

923

                if (accept(IsChar('"')))

30,376✔

924

                    break;

2,637✔

925

                if (isEOF())

27,739✔

926

                    expectSuffixOrError('"', "after string");

1✔

927

30,381✔

929

            return positioned(Node(NodeType::String, res), filepos);

2,637✔

931

        return std::nullopt;

113,416✔

932

116,065✔

934

    std::optional<Node> Parser::field(const FilePosition filepos)

113,387✔

935

113,387✔

936

        std::string sym;

113,387✔

937

        if (!name(&sym))

113,387✔

938

            return std::nullopt;

68,166✔

940

        std::optional<Node> leaf { Node(NodeType::Field) };

45,221✔

941

        leaf->push_back(Node(NodeType::Symbol, sym));

45,221✔

943

        while (true)

46,220✔

945

            if (leaf->list().size() == 1 && !accept(IsChar('.')))  // Symbol:abc

46,220✔

946

                return std::nullopt;

44,250✔

948

            if (leaf->list().size() > 1 && !accept(IsChar('.')))

1,970✔

949

                break;

970✔

951

            const auto filepos_inner = getCursor();

1,000✔

952

            std::string res;

1,000✔

953

            if (!name(&res))

1,000✔

954

                errorWithNextToken("Expected a field name: <symbol>.<field>");

1✔

955

            leaf->push_back(positioned(Node(NodeType::Symbol, res), filepos_inner));

999✔

956

1,000✔

958

        return positioned(leaf, filepos);

970✔

959

113,388✔

961

    std::optional<Node> Parser::symbol(const FilePosition filepos)

112,416✔

962

112,416✔

963

        std::string res;

112,416✔

964

        if (!name(&res))

112,416✔

965

            return std::nullopt;

68,166✔

966

        return positioned(Node(NodeType::Symbol, res), filepos);

44,250✔

967

112,416✔

969

    std::optional<Node> Parser::spread(const FilePosition filepos)

113,416✔

970

113,416✔

971

        std::string res;

113,416✔

972

        if (sequence("..."))

113,416✔

974

            if (!name(&res))

29✔

975

                errorWithNextToken("Expected a name for the variadic");

1✔

976

            return positioned(Node(NodeType::Spread, res), filepos);

28✔

978

        return std::nullopt;

113,387✔

979

113,417✔

981

    std::optional<Node> Parser::nil(const FilePosition filepos)

68,166✔

982

68,166✔

983

        if (!accept(IsChar('(')))

68,166✔

984

            return std::nullopt;

32,553✔

986

        const std::string comment = newlineOrComment();

35,613✔

987

        if (!accept(IsChar(')')))

35,613✔

988

            return std::nullopt;

35,511✔

990

        if (m_mode == ParserMode::Interpret)

102✔

991

            return positioned(Node(NodeType::Symbol, "nil").attachNearestCommentBefore(comment), filepos);

92✔

992

        return positioned(Node(NodeType::List).attachNearestCommentBefore(comment), filepos);

10✔

993

68,166✔

995

    std::optional<Node> Parser::atom()

194,375✔

996

194,375✔

997

        const auto pos = getCount();

194,375✔

998

        const auto filepos = getCursor();

194,375✔

1000

        if (auto res = Parser::number(filepos); res.has_value())

194,375✔

1001

            return res;

78,316✔

1002

        backtrack(pos);

116,053✔

1004

        if (auto res = Parser::string(filepos); res.has_value())

116,053✔

1005

            return res;

2,637✔

1006

        backtrack(pos);

113,415✔

1008

        if (auto res = Parser::spread(filepos); m_allow_macro_behavior > 0 && res.has_value())

113,415✔

1009

            return res;

28✔

1010

        backtrack(pos);

113,386✔

1012

        if (auto res = Parser::field(filepos); res.has_value())

113,386✔

1013

            return res;

970✔

1014

        backtrack(pos);

112,416✔

1016

        if (auto res = Parser::symbol(filepos); res.has_value())

112,416✔

1017

            return res;

44,250✔

1018

        backtrack(pos);

68,166✔

1020

        if (auto res = Parser::nil(filepos); res.has_value())

68,166✔

1021

            return res;

102✔

1022

        backtrack(pos);

68,064✔

1024

        return std::nullopt;

68,064✔

1025

194,375✔

1027

    std::optional<Node> Parser::anyAtomOf(const std::initializer_list<NodeType> types)

22,639✔

1028

22,639✔

1029

        if (auto value = atom(); value.has_value())

44,211✔

1031

            for (const auto type : types)

43,239✔

1033

                if (value->nodeType() == type)

21,667✔

1034

                    return value;

21,571✔

1035

21,667✔

1036

1✔

1037

        return std::nullopt;

1,068✔

1038

22,639✔

1040

    std::optional<Node> Parser::nodeOrValue()

171,728✔

1041

171,728✔

1042

        if (auto value = atom(); value.has_value())

171,728✔

1043

            return value;

104,731✔

1044

        if (auto sub_node = node(); sub_node.has_value())

66,987✔

1045

            return sub_node;

39,511✔

1047

        return std::nullopt;

27,476✔

1048

171,728✔

1050

    std::optional<Node> Parser::wrapped(std::optional<Node> (Parser::*parser)(FilePosition), const std::string& name)

355,514✔

1051

355,514✔

1052

        const auto cursor = getCursor();

355,514✔

1053

        auto context = generateErrorContextAtCurrentPosition();

355,514✔

1054

        if (!prefix('('))

355,514✔

1055

            return std::nullopt;

188,648✔

1057

        const std::string comment = newlineOrComment();

166,866✔

1059

        if (auto result = (this->*parser)(cursor); result.has_value())

184,347✔

1061

            result->attachNearestCommentBefore(result->comment() + comment);

17,481✔

1062

            result.value().attachCommentAfter(newlineOrComment());

17,481✔

1064

            if (name == "function")

17,481✔

1065

                expectSuffixOrError(')', "after function body. Did you forget to wrap the body with `{}'?", context);

3,884✔

1067

                expectSuffixOrError(')', "after " + name, context);

13,597✔

1069

            result.value().attachCommentAfter(spaceComment());

17,479✔

1070

            return result;

17,479✔

1073

        return std::nullopt;

149,362✔

1074

355,516✔

ArkScript-lang / Ark / 22281229261

Source File
Press 'n' to go to next uncovered line, 'b' for previous

ArkScript-lang / Ark / 22281229261

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous