Experimental parser: more verification

tools/lexer_generator/dfa_minimizer.py

 # Copyright 2014 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 71 matching lines @@
 
     # First we partition the states into the following groups:
     # - terminal states without action
     # - nonterminal states without action
     # - one group per action: terminal states which have the action
     # - one group per action: nonterminal states which have the action
     # These are the keys of initial_partitions. The values are lists of state
     # IDs.
     initial_partitions = {}
     terminal_set = self.__dfa.terminal_set()
-    all_keys = [] # Will contain all TransitionKeys in the dfa.
 
     # f fills in initial_partitions, id_to_state and all_keys.
     def f(state, visitor_state):
       state_id = len(id_to_state)
       id_to_state[state_id] = state
       action = state.action()
-      all_keys.append(state.key_iter())
       if state in terminal_set:
         key = ("terminal set", action)
       else:
         # Match actions are valid only if we have matched the whole token, not
         # just some sub-part of it.
         # TODO(dcarney): restore
         # assert not action.is_match_action()
         key = ("nonterminal set", action)
       if not key in initial_partitions:
         initial_partitions[key] = set()
@@ skipping 16 matching lines @@
     # two states of the dfa can be in the same partition. See the doc string of
     # TransitionKey.disjoint_keys.
 
     # For example, if the TransitionKeys are {[a-d], [c-h]}, the alphabet is
     # {[a-b], [c-d], [e-h]}. If state S1 has a transition to S2 with
     # TransitionKey [a-d], and state S3 has a transition to S4 with
     # TransitionKey [c-h], S1 and S3 cannot be in the same partition. This will
     # become clear when we check the transition for TransitionKey [c-d] (S1 has
     # a transition to S2, S3 has a transition to S4).
     encoding = self.__dfa.encoding()
-    self.__alphabet = list(
-        TransitionKey.disjoint_keys(encoding, chain(*all_keys)))
+    self.__alphabet = list(self.__dfa.disjoint_keys_iter())
 
     # For each state and each TransitionKey in the alphabet, find out which
     # transition we take from the state with the TransitionKey.
     transitions = {}
     for state_id, state in id_to_state.items():
       def f((key_id, key)):
         transition_state = state.transition_state_for_key(key)
         if transition_state:
           return state_to_id[transition_state]
         return None
@@ skipping 145 matching lines @@
           elif len(intersection) <= len(difference):
             working_set.add(intersection)
           else:
             working_set.add(difference)
         if old_partitions:
           partitions -= old_partitions
         if new_partitions:
           partitions |= new_partitions
     (start_name, mapping) = self.__create_states_from_partitions(partitions)
     return Dfa(self.__dfa.encoding(), start_name, mapping)