Fix typo 'bloc' -> 'block'

src/language/ASTBuilder.cpp

@@ -110,31 +110,32 @@ struct ASTBuilder::simplify_unary : parse_tree::apply<ASTBuilder::simplify_unary
   }
 };
 
-struct ASTBuilder::simplify_statement_bloc : parse_tree::apply<ASTBuilder::simplify_statement_bloc>
+struct ASTBuilder::simplify_statement_block : parse_tree::apply<ASTBuilder::simplify_statement_block>
 {
   template <typename... States>
   static void
   transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
-    if ((n->id == typeid(language::statement_bloc) or n->id == typeid(language::bloc)) and (n->children.size() == 1)) {
+    if ((n->id == typeid(language::statement_block) or n->id == typeid(language::block)) and
+        (n->children.size() == 1)) {
       if (not n->children[0]->is<language::declaration>()) {
         n->remove_content();
         n = std::move(n->children.back());
         transform(n, st...);
       } else {
-        n->id = typeid(language::bloc);
+        n->id = typeid(language::block);
       }
     }
   }
 };
 
-struct ASTBuilder::simplify_for_statement_bloc : parse_tree::apply<ASTBuilder::simplify_for_statement_bloc>
+struct ASTBuilder::simplify_for_statement_block : parse_tree::apply<ASTBuilder::simplify_for_statement_block>
 {
   template <typename... States>
   static void
   transform(std::unique_ptr<ASTNode>& n, States&&... st)
   {
-    if ((n->id == typeid(language::for_statement_bloc) or n->id == typeid(language::bloc)) and
+    if ((n->id == typeid(language::for_statement_block) or n->id == typeid(language::block)) and
         (n->children.size() == 1)) {
       n->remove_content();
       n = std::move(n->children.back());
@@ -247,9 +248,9 @@ using selector =
                                                       unary_minusminus,
                                                       post_minusminus,
                                                       post_plusplus>,
-                       ASTBuilder::simplify_for_statement_bloc::on<for_statement_bloc>,
-                       parse_tree::discard_empty::on<ignored, semicol, bloc>,
-                       ASTBuilder::simplify_statement_bloc::on<statement_bloc>,
+                       ASTBuilder::simplify_for_statement_block::on<for_statement_block>,
+                       parse_tree::discard_empty::on<ignored, semicol, block>,
+                       ASTBuilder::simplify_statement_block::on<statement_block>,
                        ASTBuilder::simplify_for_init::on<for_init>,
                        ASTBuilder::simplify_for_test::on<for_test>,
                        ASTBuilder::simplify_for_post::on<for_post>,

src/language/ASTBuilder.hpp

@@ -9,8 +9,8 @@ struct ASTBuilder
  private:
   struct rearrange;
   struct simplify_unary;
-  struct simplify_statement_bloc;
-  struct simplify_for_statement_bloc;
+  struct simplify_statement_block;
+  struct simplify_for_statement_block;
   struct simplify_for_init;
   struct simplify_for_test;
   struct simplify_for_post;

src/language/ASTNodeDataTypeBuilder.cpp

@@ -7,7 +7,7 @@
 void
 ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
 {
-  if (n.is<language::bloc>() or n.is<language::for_statement>()) {
+  if (n.is<language::block>() or n.is<language::for_statement>()) {
     for (auto& child : n.children) {
       this->_buildNodeDataTypes(*child);
     }
@@ -68,11 +68,11 @@ ASTNodeDataTypeBuilder::_buildNodeDataTypes(ASTNode& n)
     } else if (n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or
                n.is<language::pluseq_op>() or n.is<language::minuseq_op>()) {
       n.m_data_type = n.children[0]->m_data_type;
-    } else if (n.is<language::for_post>() or n.is<language::for_init>() or n.is<language::for_statement_bloc>()) {
+    } else if (n.is<language::for_post>() or n.is<language::for_init>() or n.is<language::for_statement_block>()) {
       n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::for_test>()) {
       n.m_data_type = ASTNodeDataType::bool_t;
-    } else if (n.is<language::statement_bloc>()) {
+    } else if (n.is<language::statement_block>()) {
       n.m_data_type = ASTNodeDataType::void_t;
     } else if (n.is<language::if_statement>() or n.is<language::while_statement>()) {
       n.m_data_type = ASTNodeDataType::void_t;

src/language/ASTNodeExpressionBuilder.cpp

@@ -21,7 +21,7 @@
 void
 ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
 {
-  if (n.is<language::bloc>()) {
+  if (n.is<language::block>()) {
     n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if ((n.is<language::eq_op>() or n.is<language::multiplyeq_op>() or n.is<language::divideeq_op>() or
               n.is<language::pluseq_op>() or n.is<language::minuseq_op>())) {
@@ -63,7 +63,7 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
     n.m_node_processor = std::make_unique<OStreamProcessor>(n, std::clog);
   } else if (n.is<language::if_statement>()) {
     n.m_node_processor = std::make_unique<IfProcessor>(n);
-  } else if (n.is<language::statement_bloc>()) {
+  } else if (n.is<language::statement_block>()) {
     n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if (n.is<language::do_while_statement>()) {
     n.m_node_processor = std::make_unique<DoWhileProcessor>(n);
@@ -71,7 +71,7 @@ ASTNodeExpressionBuilder::_buildExpression(ASTNode& n)
     n.m_node_processor = std::make_unique<WhileProcessor>(n);
   } else if (n.is<language::for_statement>()) {
     n.m_node_processor = std::make_unique<ForProcessor>(n);
-  } else if (n.is<language::for_statement_bloc>()) {
+  } else if (n.is<language::for_statement_block>()) {
     n.m_node_processor = std::make_unique<ASTNodeListProcessor>(n);
   } else if (n.is<language::for_init>()) {
     n.m_node_processor = std::make_unique<FakeProcessor>();

src/language/ASTNodeValueBuilder.cpp

@@ -8,7 +8,7 @@
 void
 ASTNodeValueBuilder::_buildNodeValue(ASTNode& n)
 {
-  if (n.is<language::bloc>()) {
+  if (n.is<language::block>()) {
     if (!n.children.empty()) {
       for (auto& child : n.children) {
         this->_buildNodeValue(*child);

src/language/ASTSymbolTableBuilder.cpp

@@ -6,12 +6,12 @@
 void
 ASTSymbolTableBuilder::buildSymbolTable(ASTNode& n, std::shared_ptr<SymbolTable>& symbol_table)
 {
-  if (n.is<language::bloc>() or (n.is<language::for_statement>())) {
+  if (n.is<language::block>() or (n.is<language::for_statement>())) {
     if (!n.children.empty()) {
-      std::shared_ptr bloc_symbol_table = std::make_shared<SymbolTable>(symbol_table);
-      n.m_symbol_table                  = bloc_symbol_table;
+      std::shared_ptr block_symbol_table = std::make_shared<SymbolTable>(symbol_table);
+      n.m_symbol_table                   = block_symbol_table;
       for (auto& child : n.children) {
-        this->buildSymbolTable(*child, bloc_symbol_table);
+        this->buildSymbolTable(*child, block_symbol_table);
       }
     }
   } else {

src/language/PEGGrammar.hpp

@@ -200,23 +200,23 @@ struct braced_instruction_list
            // non matching braces management
            if_must< at< one< '{' > >, raise<open_brace>, until<eof> > >{};
 
-struct bloc : braced_instruction_list {};
+struct block : braced_instruction_list {};
 
-struct statement_bloc;
+struct statement_block;
 
-struct if_statement : if_must< IF, parented_expression,  statement_bloc, opt< if_must<ELSE, statement_bloc > > >{};
+struct if_statement : if_must< IF, parented_expression,  statement_block, opt< if_must<ELSE, statement_block > > >{};
 
-struct do_while_statement : if_must< DO, statement_bloc, WHILE, parented_expression >{};
+struct do_while_statement : if_must< DO, statement_block, WHILE, parented_expression >{};
 
-struct while_statement : if_must< WHILE, parented_expression, statement_bloc >{};
+struct while_statement : if_must< WHILE, parented_expression, statement_block >{};
 
 struct for_init : opt< sor< declaration, affectation, expression > >{};
 struct for_test : opt< sor< affectation, expression > >{};
 struct for_post : opt< sor< affectation, expression > >{};
 
-struct for_statement_bloc;
+struct for_statement_block;
 
-struct for_statement : if_must< FOR, open_parent, for_init, SEMICOL, for_test, SEMICOL, for_post, close_parent, for_statement_bloc >{};
+struct for_statement : if_must< FOR, open_parent, for_init, SEMICOL, for_test, SEMICOL, for_post, close_parent, for_statement_block >{};
 
 struct ostream_object : seq< sor< cout_kw, cerr_kw, clog_kw >, ignored >{};
 struct ostream_statement : seq< ostream_object, star< if_must< shift_left_op, expression, ignored > > >{};
@@ -232,14 +232,14 @@ struct instruction
           if_must< BREAK, semicol >,
           if_must< CONTINUE, semicol >,
           if_must< expression, semicol >,
-          bloc,
+          block,
           semicol>
 {};
 
 struct INSTRUCTION : seq<instruction, ignored> {};
-struct statement_bloc : seq< sor< bloc, instruction >, ignored >{};
+struct statement_block : seq< sor< block, instruction >, ignored >{};
 
-struct for_statement_bloc : seq< sor< braced_instruction_list,
+struct for_statement_block : seq< sor< braced_instruction_list,
                                       instruction >,
                                  ignored >{};
 
@@ -293,7 +293,7 @@ template <>
 inline const std::string errors<language::parented_expression>::error_message = "parse error, missing parented expression";
 
 template <>
-inline const std::string errors<language::statement_bloc>::error_message = "parse error, missing instruction";
+inline const std::string errors<language::statement_block>::error_message = "parse error, missing instruction";
 
 template <>
 inline const std::string errors<language::WHILE>::error_message = "parse error, missing 'while' statement";
@@ -304,10 +304,10 @@ template <>
 inline const std::string errors<language::open_parent>::error_message = "parse error, missing open parent '('";
 
 template <>
-inline const std::string errors<language::for_statement_bloc>::error_message = "parse error, missing for-loop body";
+inline const std::string errors<language::for_statement_block>::error_message = "parse error, missing for-loop body";
 
 template <>
-inline const std::string errors<language::slashstar>::error_message = "bloc comment was never terminated, missing '*/'";
+inline const std::string errors<language::slashstar>::error_message = "block comment was never terminated, missing '*/'";
 
 template <>
 inline const std::string errors<language::open_brace>::error_message = "open brace was never closed, missing '}'";

tests/test_ASTBuilder.cpp

@@ -105,11 +105,11 @@ string s; s = "foo";
       CHECK_AST(data, result);
     }
 
-    SECTION("empty blocs simplification")
+    SECTION("empty blocks simplification")
     {
       std::string_view data = R"(
 {
-  /* nothing but a bloc */
+  /* nothing but a block */
   {
     ; // nothing
   }
@@ -300,7 +300,7 @@ not not not false;
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc simplification (one instruction per bloc)")
+    SECTION("statement block simplification (one instruction per block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -327,7 +327,7 @@ if (a > 0) {
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc simplification (one instruction in first bloc)")
+    SECTION("statement block simplification (one instruction in first block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -347,7 +347,7 @@ if (a > 0) {
      +-(language::eq_op)
      |   +-(language::name:a)
      |   `-(language::integer:0)
-     `-(language::bloc)
+     `-(language::block)
          +-(language::eq_op)
          |   +-(language::name:a)
          |   `-(language::integer:3)
@@ -359,7 +359,7 @@ if (a > 0) {
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc simplification (one instruction in second bloc)")
+    SECTION("statement block simplification (one instruction in second block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -376,7 +376,7 @@ if (a > 0) {
      +-(language::greater_op)
      |   +-(language::name:a)
      |   `-(language::integer:0)
-     +-(language::bloc)
+     +-(language::block)
      |   +-(language::eq_op)
      |   |   +-(language::name:a)
      |   |   `-(language::integer:0)
@@ -389,7 +389,7 @@ if (a > 0) {
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc non-simplification (one declaration in each bloc)")
+    SECTION("statement block non-simplification (one declaration in each block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -405,12 +405,12 @@ if (a > 0) {
      +-(language::greater_op)
      |   +-(language::name:a)
      |   `-(language::integer:0)
-     +-(language::bloc)
+     +-(language::block)
      |   `-(language::declaration)
      |       +-(language::R_set)
      |       +-(language::name:b)
      |       `-(language::name:a)
-     `-(language::bloc)
+     `-(language::block)
          `-(language::declaration)
              +-(language::R_set)
              +-(language::name:c)
@@ -421,7 +421,7 @@ if (a > 0) {
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc simplification (one declaration in first bloc)")
+    SECTION("statement block simplification (one declaration in first block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -438,12 +438,12 @@ if (a > 0) {
      +-(language::greater_op)
      |   +-(language::name:a)
      |   `-(language::integer:0)
-     +-(language::bloc)
+     +-(language::block)
      |   `-(language::declaration)
      |       +-(language::R_set)
      |       +-(language::name:b)
      |       `-(language::name:a)
-     `-(language::bloc)
+     `-(language::block)
          +-(language::declaration)
          |   +-(language::R_set)
          |   +-(language::name:c)
@@ -456,7 +456,7 @@ if (a > 0) {
       CHECK_AST(data, result);
     }
 
-    SECTION("statement bloc simplification (one declaration in second bloc)")
+    SECTION("statement block simplification (one declaration in second block)")
     {
       std::string_view data = R"(
 if (a > 0) {
@@ -473,14 +473,14 @@ if (a > 0) {
      +-(language::greater_op)
      |   +-(language::name:a)
      |   `-(language::integer:0)
-     +-(language::bloc)
+     +-(language::block)
      |   +-(language::declaration)
      |   |   +-(language::R_set)
      |   |   +-(language::name:b)
      |   |   `-(language::name:a)
      |   `-(language::unary_plusplus)
      |       `-(language::name:b)
-     `-(language::bloc)
+     `-(language::block)
          `-(language::declaration)
              +-(language::R_set)
              +-(language::name:c)
@@ -518,7 +518,7 @@ for(N i=0; i<10; ++i) {
       CHECK_AST(data, result);
     }
 
-    SECTION("for-statements simplification (complex bloc)")
+    SECTION("for-statements simplification (complex block)")
     {
       std::string_view data = R"(
 for(N i=0; i<10; ++i) {
@@ -539,7 +539,7 @@ for(N i=0; i<10; ++i) {
      |   `-(language::integer:10)
      +-(language::unary_plusplus)
      |   `-(language::name:i)
-     `-(language::for_statement_bloc)
+     `-(language::for_statement_block)
          +-(language::pluseq_op)
          |   +-(language::name:i)
          |   `-(language::integer:3)

tests/test_ASTNodeDataTypeBuilder.cpp

@@ -81,7 +81,7 @@ false;
     CHECK_AST(data, result);
   }
 
-  SECTION("bloc")
+  SECTION("block")
   {
     std::string_view data = R"(
 {
@@ -92,7 +92,7 @@ false;
 
     std::string_view result = R"(
 (root:void)
- `-(language::bloc:void)
+ `-(language::block:void)
      +-(language::integer:1:Z)
      `-(language::real:2.3:R)
 )";
@@ -373,7 +373,7 @@ for (;;);
      +-(language::for_init:void)
      +-(language::for_test:B)
      +-(language::for_post:void)
-     `-(language::for_statement_bloc:void)
+     `-(language::for_statement_block:void)
 )";
 
     CHECK_AST(data, result);
@@ -406,7 +406,7 @@ for (Z i=0; i<3; i += 1) { i += 2; }
     CHECK_AST(data, result);
   }
 
-  SECTION("empty bloc")
+  SECTION("empty block")
   {
     std::string_view data = R"(
 {}
@@ -419,7 +419,7 @@ for (Z i=0; i<3; i += 1) { i += 2; }
     CHECK_AST(data, result);
   }
 
-  SECTION("bloc")
+  SECTION("block")
   {
     std::string_view data = R"(
 {
@@ -429,7 +429,7 @@ for (Z i=0; i<3; i += 1) { i += 2; }
 
     std::string_view result = R"(
 (root:void)
- `-(language::bloc:void)
+ `-(language::block:void)
      `-(language::integer:3:Z)
 )";
 
@@ -448,7 +448,7 @@ if (true);
 (root:void)
  `-(language::if_statement:void)
      +-(language::true_kw:B)
-     `-(language::statement_bloc:void)
+     `-(language::statement_block:void)
 )";
 
       CHECK_AST(data, result);
@@ -474,7 +474,7 @@ else
       CHECK_AST(data, result);
     }
 
-    SECTION("if else simplify bloc")
+    SECTION("if else simplify block")
     {
       std::string_view data = R"(
 if (true) {
@@ -495,7 +495,7 @@ if (true) {
       CHECK_AST(data, result);
     }
 
-    SECTION("if bloc")
+    SECTION("if block")
     {
       std::string_view data = R"(
 if (true) {
@@ -508,7 +508,7 @@ if (true) {
 (root:void)
  `-(language::if_statement:void)
      +-(language::true_kw:B)
-     `-(language::bloc:void)
+     `-(language::block:void)
          +-(language::integer:1:Z)
          `-(language::integer:2:Z)
 )";
@@ -541,7 +541,7 @@ while (true);
 (root:void)
  `-(language::while_statement:void)
      +-(language::true_kw:B)
-     `-(language::statement_bloc:void)
+     `-(language::statement_block:void)
 )";
 
       CHECK_AST(data, result);
@@ -563,7 +563,7 @@ while (true) 1;
       CHECK_AST(data, result);
     }
 
-    SECTION("while simplified bloc")
+    SECTION("while simplified block")
     {
       std::string_view data = R"(
 while (true) {
@@ -581,7 +581,7 @@ while (true) {
       CHECK_AST(data, result);
     }
 
-    SECTION("while bloc_statement")
+    SECTION("while block_statement")
     {
       std::string_view data = R"(
 while (true) {
@@ -594,7 +594,7 @@ while (true) {
 (root:void)
  `-(language::while_statement:void)
      +-(language::true_kw:B)
-     `-(language::bloc:void)
+     `-(language::block:void)
          +-(language::integer:1:Z)
          `-(language::integer:2:Z)
 )";
@@ -626,7 +626,7 @@ do ; while (true);
       std::string_view result = R"(
 (root:void)
  `-(language::do_while_statement:void)
-     +-(language::statement_bloc:void)
+     +-(language::statement_block:void)
      `-(language::true_kw:B)
 )";
 
@@ -649,7 +649,7 @@ do 1; while (true);
       CHECK_AST(data, result);
     }
 
-    SECTION("do-while simplified bloc")
+    SECTION("do-while simplified block")
     {
       std::string_view data = R"(
 do {
@@ -667,7 +667,7 @@ do {
       CHECK_AST(data, result);
     }
 
-    SECTION("do-while bloc")
+    SECTION("do-while block")
     {
       std::string_view data = R"(
 do {
@@ -679,7 +679,7 @@ do {
       std::string_view result = R"(
 (root:void)
  `-(language::do_while_statement:void)
-     +-(language::bloc:void)
+     +-(language::block:void)
      |   +-(language::integer:1:Z)
      |   `-(language::integer:2:Z)
      `-(language::true_kw:B)

tests/test_ASTNodeDeclarationCleaner.cpp

@@ -85,7 +85,7 @@ if (true) {
  |   `-(language::integer:1)
  `-(language::if_statement)
      +-(language::true_kw)
-     `-(language::bloc)
+     `-(language::block)
          `-(language::eq_op)
              +-(language::name:x)
              `-(language::multiply_op)

tests/test_ASTNodeDeclarationToAffectationConverter.cpp

@@ -89,7 +89,7 @@ for(N i=0; i<2; ++i) {
      |   `-(language::integer:2)
      +-(language::unary_plusplus)
      |   `-(language::name:i)
-     `-(language::for_statement_bloc)
+     `-(language::for_statement_block)
          +-(language::eq_op)
          |   +-(language::name:j)
          |   `-(language::plus_op)

tests/test_ASTNodeExpressionBuilder.cpp

@@ -128,7 +128,7 @@ false;
     }
   }
 
-  SECTION("bloc")
+  SECTION("block")
   {
     std::string_view data = R"(
 {
@@ -138,7 +138,7 @@ false;
 
     std::string result = R"(
 (root:ASTNodeListProcessor)
- `-(language::bloc:ASTNodeListProcessor)
+ `-(language::block:ASTNodeListProcessor)
      `-(language::integer:1:FakeProcessor)
 )";
 
@@ -682,7 +682,7 @@ if(true);
 (root:ASTNodeListProcessor)
  `-(language::if_statement:IfProcessor)
      +-(language::true_kw:FakeProcessor)
-     `-(language::statement_bloc:ASTNodeListProcessor)
+     `-(language::statement_block:ASTNodeListProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -697,7 +697,7 @@ do; while(true);
       std::string result = R"(
 (root:ASTNodeListProcessor)
  `-(language::do_while_statement:DoWhileProcessor)
-     +-(language::statement_bloc:ASTNodeListProcessor)
+     +-(language::statement_block:ASTNodeListProcessor)
      `-(language::true_kw:FakeProcessor)
 )";
 
@@ -714,7 +714,7 @@ while(true);
 (root:ASTNodeListProcessor)
  `-(language::while_statement:WhileProcessor)
      +-(language::true_kw:FakeProcessor)
-     `-(language::statement_bloc:ASTNodeListProcessor)
+     `-(language::statement_block:ASTNodeListProcessor)
 )";
 
       CHECK_AST(data, result);
@@ -739,7 +739,7 @@ for(N i=0; i<10; ++i);
      |   `-(language::integer:10:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
-     `-(language::for_statement_bloc:ASTNodeListProcessor)
+     `-(language::for_statement_block:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -764,7 +764,7 @@ for(; i<10; ++i);
      |   `-(language::integer:10:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
-     `-(language::for_statement_bloc:ASTNodeListProcessor)
+     `-(language::for_statement_block:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -785,7 +785,7 @@ for(N i=0; ; ++i);
      +-(language::for_test:FakeProcessor)
      +-(language::unary_plusplus:IncDecExpressionProcessor<language::unary_plusplus, unsigned long>)
      |   `-(language::name:i:NameProcessor)
-     `-(language::for_statement_bloc:ASTNodeListProcessor)
+     `-(language::for_statement_block:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);
@@ -807,7 +807,7 @@ for(N i=0; i<10;);
      |   +-(language::name:i:NameProcessor)
      |   `-(language::integer:10:FakeProcessor)
      +-(language::for_post:FakeProcessor)
-     `-(language::for_statement_bloc:ASTNodeListProcessor)
+     `-(language::for_statement_block:ASTNodeListProcessor)
 )";
 
         CHECK_AST(data, result);

tests/test_ASTNodeValueBuilder.cpp

@@ -111,13 +111,13 @@ for(;;);
      +-(language::for_init:--)
      +-(language::for_test:1)
      +-(language::for_post:--)
-     `-(language::for_statement_bloc:--)
+     `-(language::for_statement_block:--)
 )";
 
     CHECK_AST_VALUES(data, result);
   }
 
-  SECTION("bloc values")
+  SECTION("block values")
   {
     std::string_view data = R"(
 {
@@ -128,7 +128,7 @@ for(;;);
 
     std::string_view result = R"(
 (root:--)
- `-(language::bloc:--)
+ `-(language::block:--)
      +-(language::integer:1:1)
      `-(language::real:2.3:2.3)
 )";