Remove outer namespacing class

assets/parser.d.erb

@@ -9,8 +9,6 @@ import std.stdio;
 <%= code %>
 <% end %>
 
-class <%= @classname %>
-{
 /* Result codes. */
 public enum : size_t
 {
@@ -26,9 +24,11 @@ class <%= @classname %>
 /* An invalid ID value. */
 private enum size_t INVALID_ID = cast(size_t)-1;
 
-    alias Token = <%= get_type_for(@grammar.invalid_token_id) %>;
+/** Token ID type. */
+public alias Token = <%= get_type_for(@grammar.invalid_token_id) %>;
 
-    enum : Token
+/** Token IDs. */
+public enum : Token
 {
 <% @grammar.tokens.each_with_index do |token, index| %>
     TOKEN_<%= token.code_name %> = <%= index %>,
@@ -39,15 +39,18 @@ class <%= @classname %>
     INVALID_TOKEN_ID = <%= @grammar.invalid_token_id %>,
 }
 
-    alias CodePoint = uint;
+/** Token names. */
-
+public static immutable string[] token_names = [
-    static immutable string[] token_names = [
 <% @grammar.tokens.each_with_index do |token, index| %>
     "<%= token.name %>",
 <% end %>
 ];
 
-    static union ParserValue
+/** Code point type. */
+public alias CodePoint = uint;
+
+/** Parser values type(s). */
+public static union ParserValue
 {
 <% @grammar.ptypes.each do |name, typestring| %>
     <%= typestring %> v_<%= name %>;
@@ -59,7 +62,7 @@ class <%= @classname %>
  *
  * This is useful for reporting errors, etc...
  */
-    static struct Position
+public static struct Position
 {
     /** Input text row (0-based). */
     uint row;
@@ -68,7 +71,11 @@ class <%= @classname %>
     uint col;
 }
 
-    static class Decoder
+/**************************************************************************
+ * Decoder
+ *************************************************************************/
+
+public static class Decoder
 {
     /**
      * Decode a UTF-8 code point.
@@ -147,13 +154,15 @@ class <%= @classname %>
     }
 }
 
-    static class Lexer
+/**************************************************************************
-    {
+ * Lexer
-        alias LexerStateID = <%= get_type_for(@lexer.state_table.size) %>;
+ *************************************************************************/
-        enum LexerStateID INVALID_LEXER_STATE_ID = <%= @lexer.state_table.size %>u;
+
+private alias LexerStateID = <%= get_type_for(@lexer.state_table.size) %>;
+private enum LexerStateID INVALID_LEXER_STATE_ID = <%= @lexer.state_table.size %>u;
 <% user_code_id_count = (@grammar.patterns.map(&:code_id).compact.max || 0) + 1 %>
-        alias UserCodeID = <%= get_type_for(user_code_id_count) %>;
+private alias UserCodeID = <%= get_type_for(user_code_id_count) %>;
-        enum UserCodeID INVALID_USER_CODE_ID = <%= user_code_id_count %>u;
+private enum UserCodeID INVALID_USER_CODE_ID = <%= user_code_id_count %>u;
 
 private struct Transition
 {
@@ -176,7 +185,7 @@ class <%= @classname %>
     uint state_table_offset;
 }
 
-        private static immutable Transition[] transitions = [
+private static immutable Transition[] lexer_transitions = [
 <% @lexer.transition_table.each do |transition_table_entry| %>
     Transition(<%= transition_table_entry[:first] %>u,
                <%= transition_table_entry[:last] %>u,
@@ -184,7 +193,7 @@ class <%= @classname %>
 <% end %>
 ];
 
-        private static immutable LexerState[] states = [
+private static immutable LexerState[] lexer_states = [
 <% @lexer.state_table.each do |state_table_entry| %>
 LexerState(<%= state_table_entry[:transition_table_index] %>u,
 <%= state_table_entry[:n_transitions] %>u,
@@ -216,6 +225,8 @@ class <%= @classname %>
     ParserValue pvalue;
 }
 
+public static class Lexer
+{
     private string m_input;
     private size_t m_input_index;
     private Position m_input_position;
@@ -385,9 +396,9 @@ class <%= @classname %>
                         attempt_match.delta_position.col++;
                     }
                     current_state = transition_state;
-                        if (states[current_state].accepts)
+                    if (lexer_states[current_state].accepts)
                     {
-                            attempt_match.accepting_state = &states[current_state];
+                        attempt_match.accepting_state = &lexer_states[current_state];
                         longest_match = attempt_match;
                     }
                 }
@@ -432,30 +443,32 @@ class <%= @classname %>
 
     private LexerStateID transition(uint current_state, uint code_point)
     {
-            uint transition_table_index = states[current_state].transition_table_index;
+        uint transition_table_index = lexer_states[current_state].transition_table_index;
-            for (uint i = 0u; i < states[current_state].n_transitions; i++)
+        for (uint i = 0u; i < lexer_states[current_state].n_transitions; i++)
         {
-                if ((transitions[transition_table_index + i].first <= code_point) &&
+            if ((lexer_transitions[transition_table_index + i].first <= code_point) &&
-                    (code_point <= transitions[transition_table_index + i].last))
+                (code_point <= lexer_transitions[transition_table_index + i].last))
             {
-                    return transitions[transition_table_index + i].destination_state;
+                return lexer_transitions[transition_table_index + i].destination_state;
             }
         }
         return INVALID_LEXER_STATE_ID;
     }
 }
 
-    static class Parser
+/**************************************************************************
-    {
+ * Parser
-        alias ReduceID = <%= get_type_for(@parser.reduce_table.size) %>;
+ *************************************************************************/
+
+private alias ReduceID = <%= get_type_for(@parser.reduce_table.size) %>;
 <% # A "symbol" is either a token ID or a rule set ID. %>
 <% # %>
 <% # Rule set IDs start after token IDs, so to store either a token ID %>
 <% # or a rule set ID, we just need to know the maximum rule set ID. %>
-        alias SymbolID = <%= get_type_for(@parser.rule_sets.map(&:last).map(&:id).max) %>;
+private alias SymbolID = <%= get_type_for(@parser.rule_sets.map(&:last).map(&:id).max) %>;
-        alias StateID = <%= get_type_for(@parser.state_table.size) %>;
+private alias StateID = <%= get_type_for(@parser.state_table.size) %>;
-        alias RuleID = <%= get_type_for(@grammar.rules.size) %>;
+private alias RuleID = <%= get_type_for(@grammar.rules.size) %>;
-        alias ShiftID = <%= get_type_for(@parser.shift_table.size) %>;
+private alias ShiftID = <%= get_type_for(@parser.shift_table.size) %>;
 
 private struct Shift
 {
@@ -490,24 +503,26 @@ class <%= @classname %>
     }
 }
 
-        private static immutable Shift[] shifts = [
+private static immutable Shift[] parser_shifts = [
 <%   @parser.shift_table.each do |shift| %>
     Shift(<%= shift[:token_id] %>u, <%= shift[:state_id] %>u),
 <%   end %>
 ];
 
-        private static immutable Reduce[] reduces = [
+private static immutable Reduce[] parser_reduces = [
 <%   @parser.reduce_table.each do |reduce| %>
     Reduce(<%= reduce[:token_id] %>u, <%= reduce[:rule_id] %>u, <%= reduce[:rule_set_id] %>u, <%= reduce[:n_states] %>u),
 <%   end %>
 ];
 
-        private static immutable ParserState[] states = [
+private static immutable ParserState[] parser_states = [
 <%   @parser.state_table.each do |state| %>
     ParserState(<%= state[:shift_index] %>u, <%= state[:n_shifts] %>u, <%= state[:reduce_index] %>u, <%= state[:n_reduces] %>u),
 <%   end %>
 ];
 
+public static class Parser
+{
     private Lexer m_lexer;
 
     private ParserValue parse_result;
@@ -519,7 +534,7 @@ class <%= @classname %>
 
     size_t parse()
     {
-            Lexer.TokenInfo token_info;
+        TokenInfo token_info;
         Token token = INVALID_TOKEN_ID;
         StateValue[] statevalues = new StateValue[](1);
         size_t reduced_rule_set = INVALID_ID;
@@ -575,9 +590,9 @@ class <%= @classname %>
             if (reduce_index != INVALID_ID)
             {
                 /* We have something to reduce. */
-                    reduced_parser_value = user_code(reduces[reduce_index].rule, statevalues, reduces[reduce_index].n_states);
+                reduced_parser_value = user_code(parser_reduces[reduce_index].rule, statevalues, parser_reduces[reduce_index].n_states);
-                    reduced_rule_set = reduces[reduce_index].rule_set;
+                reduced_rule_set = parser_reduces[reduce_index].rule_set;
-                    statevalues.length -= reduces[reduce_index].n_states;
+                statevalues.length -= parser_reduces[reduce_index].n_states;
                 continue;
             }
 
@@ -602,11 +617,11 @@ class <%= @classname %>
 
     private size_t check_shift(size_t state, size_t symbol)
     {
-            uint start = states[state].shift_table_index;
+        uint start = parser_states[state].shift_table_index;
-            uint end = start + states[state].n_shift_entries;
+        uint end = start + parser_states[state].n_shift_entries;
         for (uint i = start; i < end; i++)
         {
-                if (shifts[i].symbol == symbol)
+            if (parser_shifts[i].symbol == symbol)
             {
 //                    if (symbol != INVALID_TOKEN_ID)
 //                    {
@@ -616,7 +631,7 @@ class <%= @classname %>
 //                    {
 //                        writeln("Shifting rule set ", symbol);
 //                    }
-                    return shifts[i].state;
+                return parser_shifts[i].state;
             }
         }
         return INVALID_ID;
@@ -624,14 +639,14 @@ class <%= @classname %>
 
     private size_t check_reduce(size_t state, Token token)
     {
-            size_t start = states[state].reduce_table_index;
+        size_t start = parser_states[state].reduce_table_index;
-            size_t end = start + states[state].n_reduce_entries;
+        size_t end = start + parser_states[state].n_reduce_entries;
         for (size_t i = start; i < end; i++)
         {
-                if ((reduces[i].token == token) ||
+            if ((parser_reduces[i].token == token) ||
-                    (reduces[i].token == INVALID_TOKEN_ID))
+                (parser_reduces[i].token == INVALID_TOKEN_ID))
             {
-//                    write("Reducing rule ", reduces[i].rule, ", rule set ", reduces[i].rule_set, " lookahead ");
+//                    write("Reducing rule ", parser_reduces[i].rule, ", rule set ", parser_reduces[i].rule_set, " lookahead ");
 //                    if (token != INVALID_TOKEN_ID)
 //                    {
 //                        writeln(token_names[token]);
@@ -672,4 +687,3 @@ class <%= @classname %>
         return _pvalue;
     }
 }
-}

spec/test_d_lexer.d

@@ -9,61 +9,60 @@ int main()
 unittest
 {
     size_t result;
-    Testparser.CodePoint code_point;
+    CodePoint code_point;
     ubyte code_point_length;
 
-    result = Testparser.Decoder.decode_code_point("5", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("5", &code_point, &code_point_length);
-    assert(result == Testparser.P_SUCCESS);
+    assert(result == P_SUCCESS);
     assert(code_point == '5');
     assert(code_point_length == 1u);
 
-    result = Testparser.Decoder.decode_code_point("", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("", &code_point, &code_point_length);
-    assert(result == Testparser.P_EOF);
+    assert(result == P_EOF);
 
-    result = Testparser.Decoder.decode_code_point("\xC2\xA9", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("\xC2\xA9", &code_point, &code_point_length);
-    assert(result == Testparser.P_SUCCESS);
+    assert(result == P_SUCCESS);
     assert(code_point == 0xA9u);
     assert(code_point_length == 2u);
 
-    result = Testparser.Decoder.decode_code_point("\xf0\x9f\xa7\xa1", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("\xf0\x9f\xa7\xa1", &code_point, &code_point_length);
-    assert(result == Testparser.P_SUCCESS);
+    assert(result == P_SUCCESS);
     assert(code_point == 0x1F9E1u);
     assert(code_point_length == 4u);
 
-    result = Testparser.Decoder.decode_code_point("\xf0\x9f\x27", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("\xf0\x9f\x27", &code_point, &code_point_length);
-    assert(result == Testparser.P_DECODE_ERROR);
+    assert(result == P_DECODE_ERROR);
 
-    result = Testparser.Decoder.decode_code_point("\xf0\x9f\xa7\xFF", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("\xf0\x9f\xa7\xFF", &code_point, &code_point_length);
-    assert(result == Testparser.P_DECODE_ERROR);
+    assert(result == P_DECODE_ERROR);
 
-    result = Testparser.Decoder.decode_code_point("\xfe", &code_point, &code_point_length);
+    result = Decoder.decode_code_point("\xfe", &code_point, &code_point_length);
-    assert(result == Testparser.P_DECODE_ERROR);
+    assert(result == P_DECODE_ERROR);
 }
 
 unittest
 {
-    alias TokenInfo = Testparser.Lexer.TokenInfo;
     TokenInfo token_info;
     string input = "5 + 4 * \n677 + 567";
-    Testparser.Lexer lexer = new Testparser.Lexer(input);
+    Lexer lexer = new Lexer(input);
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(0, 0), 1, Testparser.TOKEN_int));
+    assert(token_info == TokenInfo(Position(0, 0), 1, TOKEN_int));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(0, 2), 1, Testparser.TOKEN_plus));
+    assert(token_info == TokenInfo(Position(0, 2), 1, TOKEN_plus));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(0, 4), 1, Testparser.TOKEN_int));
+    assert(token_info == TokenInfo(Position(0, 4), 1, TOKEN_int));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(0, 6), 1, Testparser.TOKEN_times));
+    assert(token_info == TokenInfo(Position(0, 6), 1, TOKEN_times));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(1, 0), 3, Testparser.TOKEN_int));
+    assert(token_info == TokenInfo(Position(1, 0), 3, TOKEN_int));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(1, 4), 1, Testparser.TOKEN_plus));
+    assert(token_info == TokenInfo(Position(1, 4), 1, TOKEN_plus));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(1, 6), 3, Testparser.TOKEN_int));
+    assert(token_info == TokenInfo(Position(1, 6), 3, TOKEN_int));
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(1, 9), 0, Testparser.TOKEN___EOF));
+    assert(token_info == TokenInfo(Position(1, 9), 0, TOKEN___EOF));
 
-    lexer = new Testparser.Lexer("");
+    lexer = new Lexer("");
-    assert(lexer.lex_token(&token_info) == Testparser.P_TOKEN);
+    assert(lexer.lex_token(&token_info) == P_TOKEN);
-    assert(token_info == TokenInfo(Testparser.Position(0, 0), 0, Testparser.TOKEN___EOF));
+    assert(token_info == TokenInfo(Position(0, 0), 0, TOKEN___EOF));
 }

spec/test_d_parser_identical_rules_lookahead.d

@@ -9,10 +9,10 @@ int main()
 unittest
 {
     string input = "aba";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 
     input = "abb";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 }

spec/test_d_parser_rule_from_multiple_states.d

@@ -9,14 +9,14 @@ int main()
 unittest
 {
     string input = "a";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_UNEXPECTED_TOKEN);
+    assert(parser.parse() == P_UNEXPECTED_TOKEN);
 
     input = "a b";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 
     input = "bb";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 }

spec/test_lexer_match_text.d

@@ -9,7 +9,7 @@ int main()
 unittest
 {
     string input = `identifier_123`;
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass1");
 }

spec/test_lexer_modes.d

@@ -9,12 +9,12 @@ int main()
 unittest
 {
     string input = `abc "a string" def`;
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass1");
 
     input = `abc "abc def" def`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass2");
 }

spec/test_lexer_result_value.d

@@ -9,12 +9,12 @@ int main()
 unittest
 {
     string input = `x`;
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 1u);
 
     input = `fabulous`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 8u);
 }

spec/test_lexer_unknown_character.d

@@ -9,11 +9,11 @@ int main()
 unittest
 {
     string input = `x`;
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_UNEXPECTED_INPUT);
+    assert(parser.parse() == P_UNEXPECTED_INPUT);
 
     input = `123`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 123u);
 }

spec/test_parser_rule_user_code.d

@@ -9,6 +9,6 @@ int main()
 unittest
 {
     string input = "ab";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 }

spec/test_parsing_json.d

@@ -10,42 +10,42 @@ int main()
 unittest
 {
     string input = ``;
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 
     input = `{}`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONObject)parser.result);
 
     input = `[]`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONArray)parser.result);
 
     input = `-45.6`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONNumber)parser.result);
     assert((cast(JSONNumber)parser.result).value == -45.6);
 
     input = `2E-2`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONNumber)parser.result);
     assert((cast(JSONNumber)parser.result).value == 0.02);
 
     input = `{"hi":true}`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONObject)parser.result);
     JSONObject o = cast(JSONObject)parser.result;
     assert(o.value["hi"]);
     assert(cast(JSONTrue)o.value["hi"]);
 
     input = `{"ff": false, "nn": null}`;
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(cast(JSONObject)parser.result);
     o = cast(JSONObject)parser.result;
     assert(o.value["ff"]);

spec/test_parsing_lists.d

@@ -9,17 +9,17 @@ int main()
 unittest
 {
     string input = "a";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 1u);
 
     input = "";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 0u);
 
     input = "aaaaaaaaaaaaaaaa";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     assert(parser.result == 16u);
 }

spec/test_pattern.d

@@ -9,12 +9,12 @@ int main()
 unittest
 {
     string input = "abcdef";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass1");
 
     input = "defabcdef";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass2");
 }

spec/test_return_token_from_pattern.d

@@ -9,6 +9,6 @@ int main()
 unittest
 {
     string input = "defghidef";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
 }

spec/test_user_code.d

@@ -9,12 +9,12 @@ int main()
 unittest
 {
     string input = "abcdef";
-    auto parser = new Testparser.Parser(input);
+    auto parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass1");
 
     input = "abcabcdef";
-    parser = new Testparser.Parser(input);
+    parser = new Parser(input);
-    assert(parser.parse() == Testparser.P_SUCCESS);
+    assert(parser.parse() == P_SUCCESS);
     writeln("pass2");
 }