Add allMatches to Traverse function to improve performance

src/SIL.Machine/FeatureModel/VariableBindings.cs

@@ -142,5 +142,40 @@ public VariableBindings Clone()
         {
             return new VariableBindings(this);
         }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(this, obj))
+                return true;
+
+            if (!(obj is VariableBindings other) || _varBindings.Count != other._varBindings.Count)
+                return false;
+
+            foreach (KeyValuePair<string, SimpleFeatureValue> binding in _varBindings)
+            {
+                SimpleFeatureValue otherValue;
+                if (!other._varBindings.TryGetValue(binding.Key, out otherValue))
+                    return false;
+
+                if (binding.Value == null ? otherValue != null : !binding.Value.ValueEquals(otherValue))
+                    return false;
+            }
+
+            return true;
+        }
+
+        public override int GetHashCode()
+        {
+            int hashCode = 17;
+            foreach (KeyValuePair<string, SimpleFeatureValue> binding in _varBindings)
+            {
+                int bindingHashCode = binding.Key.GetHashCode();
+                if (binding.Value != null)
+                    bindingHashCode = bindingHashCode * 31 + binding.Value.ToString().GetHashCode();
+                hashCode += bindingHashCode;
+            }
+
+            return hashCode;
+        }
     }
 }

src/SIL.Machine/FiniteState/DeterministicFsaTraversalMethod.cs

@@ -22,7 +22,8 @@ public override IEnumerable<FstResult<TData, TOffset>> Traverse(
             ref int annIndex,
             Register<TOffset>[,] initRegisters,
             IList<TagMapCommand> initCmds,
-            ISet<int> initAnns
+            ISet<int> initAnns,
+            bool allMatches
         )
         {
             Stack<DeterministicFsaTraversalInstance<TData, TOffset>> instStack = InitializeStack(
@@ -33,15 +34,20 @@ ISet<int> initAnns
             );
 
             var curResults = new List<FstResult<TData, TOffset>>();
+            var lattice = !Fst.HasAcceptable ? CreateFstLattice() : null;
+
             while (instStack.Count != 0)
             {
                 DeterministicFsaTraversalInstance<TData, TOffset> inst = instStack.Pop();
+                DeterministicFsaTraversalInstance<TData, TOffset> origInst =
+                    lattice != null ? CopyInstanceAndBindings(inst) : null;
 
                 bool releaseInstance = true;
                 foreach (Arc<TData, TOffset> arc in inst.State.Arcs)
                 {
                     if (CheckInputMatch(arc, inst.AnnotationIndex, inst.VariableBindings))
                     {
+                        int resultCount = lattice != null ? curResults.Count : 0;
                         foreach (
                             DeterministicFsaTraversalInstance<TData, TOffset> ni in Advance(
                                 inst,
@@ -51,9 +57,14 @@ DeterministicFsaTraversalInstance<TData, TOffset> ni in Advance(
                             )
                         )
                         {
+                            if (lattice != null && RecordedInstance(lattice, ni, origInst, arc))
+                                continue;
                             instStack.Push(ni);
                         }
 
+                        if (lattice != null && curResults.Count > resultCount)
+                            RecordFinalArc(lattice, origInst, arc);
+
                         releaseInstance = false;
                         break;
                     }
@@ -63,6 +74,11 @@ DeterministicFsaTraversalInstance<TData, TOffset> ni in Advance(
                     ReleaseInstance(inst);
             }
 
+            if (lattice != null)
+            {
+                curResults = ExtractResults(lattice, allMatches);
+            }
+
             CheckAcceptingStartState(initAnns, initRegisters, curResults);
 
             return curResults;

src/SIL.Machine/FiniteState/DeterministicFstTraversalMethod.cs

@@ -26,7 +26,8 @@ public override IEnumerable<FstResult<TData, TOffset>> Traverse(
             ref int annIndex,
             Register<TOffset>[,] initRegisters,
             IList<TagMapCommand> initCmds,
-            ISet<int> initAnns
+            ISet<int> initAnns,
+            bool allMatches
         )
         {
             Stack<DeterministicFstTraversalInstance<TData, TOffset>> instStack = InitializeStack(

src/SIL.Machine/FiniteState/Fst.cs

@@ -56,10 +56,23 @@ public Fst(IFstOperations<TData, TOffset> operations, IEqualityComparer<TOffset>
             _filter = ann => true;
             _registersEqualityComparer = new RegistersEqualityComparer<TOffset>(offsetEqualityComparer);
             _offsetEqualityComparer = offsetEqualityComparer;
+            foreach (State<TData, TOffset> state in States)
+            {
+                foreach (AcceptInfo<TData, TOffset> acceptInfo in state.AcceptInfos)
+                {
+                    if (acceptInfo.Acceptable != null)
+                    {
+                        HasAcceptable = true;
+                        break;
+                    }
+                }
+            }
         }
 
         public bool IsDeterministic { get; private set; }
 
+        public bool HasAcceptable { get; private set; }
+
         public State<TData, TOffset> CreateAcceptingState()
         {
             CheckFrozen();
@@ -387,7 +400,7 @@ out IEnumerable<FstResult<TData, TOffset>> results
                 }
 
                 List<FstResult<TData, TOffset>> curResults = traversalMethod
-                    .Traverse(ref annIndex, initRegisters, cmds, initAnns)
+                    .Traverse(ref annIndex, initRegisters, cmds, initAnns, allMatches)
                     .ToList();
                 if (curResults.Count > 0)
                 {
@@ -424,7 +437,12 @@ private int ResultCompare(FstResult<TData, TOffset> x, FstResult<TData, TOffset>
                 compare = -compare;
             if (IsDeterministic)
             {
-                compare = x.IsLazy ? -compare : compare;
+                if (x.IsLazy && y.IsLazy)
+                    // prefer the shorter one
+                    compare = -compare;
+                else if (x.IsLazy || y.IsLazy)
+                    // prefer the lazy one, regardless of direction
+                    compare = x.IsLazy ? -1 : 1;
             }
             else if (compare == 0)
             {

src/SIL.Machine/FiniteState/ITraversalMethod.cs

@@ -11,7 +11,8 @@ IEnumerable<FstResult<TData, TOffset>> Traverse(
             ref int annIndex,
             Register<TOffset>[,] initRegisters,
             IList<TagMapCommand> initCmds,
-            ISet<int> initAnns
+            ISet<int> initAnns,
+            bool allMatches
         );
     }
 }

src/SIL.Machine/FiniteState/NondeterministicFsaTraversalMethod.cs

@@ -24,7 +24,8 @@ public override IEnumerable<FstResult<TData, TOffset>> Traverse(
             ref int annIndex,
             Register<TOffset>[,] initRegisters,
             IList<TagMapCommand> initCmds,
-            ISet<int> initAnns
+            ISet<int> initAnns,
+            bool allMatches
         )
         {
             Stack<NondeterministicFsaTraversalInstance<TData, TOffset>> instStack = InitializeStack(

src/SIL.Machine/FiniteState/NondeterministicFstTraversalMethod.cs

@@ -27,7 +27,8 @@ public override IEnumerable<FstResult<TData, TOffset>> Traverse(
             ref int annIndex,
             Register<TOffset>[,] initRegisters,
             IList<TagMapCommand> initCmds,
-            ISet<int> initAnns
+            ISet<int> initAnns,
+            bool allMatches
         )
         {
             Stack<NondeterministicFstTraversalInstance<TData, TOffset>> instStack = InitializeStack(